UInt in typenum::uint - Rust
Description: `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.
Keywords: rust, rustlang, rust-lang, UInt

# Struct typenum::uint::UInt

source ·

    pub struct UInt<U, B> { /* private fields */ }

Expand description

`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::{UInt, UTerm, B0, B1};

    type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;

## Implementations§

source§

### impl<U: Unsigned, B: Bit> UInt<U, B>

source

#### pub fn new() -> UInt<U, B>

Instantiates a singleton representing this unsigned integer.

## Trait Implementations§

source§

### impl<U: Unsigned, B: Bit> Add<B0> for UInt<U, B>

`U + B0 = U`

§

#### type Output = UInt<U, B>

The resulting type after applying the `+` operator.
source§

#### fn add(self, _: B0) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<U: Unsigned> Add<B1> for UInt<U, B0>

`UInt<U, B0> + B1 = UInt<U + B1>`

§

#### type Output = UInt<U, B1>

The resulting type after applying the `+` operator.
source§

#### fn add(self, _: B1) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<U> Add<B1> for UInt<U, B1>where
U: Add<B1> + Unsigned,
Add1<U>: 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.
source§

#### fn add(self, _: B1) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<Ul, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B0>where
Ul: Add<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.
source§

#### fn add(self, rhs: UInt<Ur, B0>) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<Ul, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B1>where
Ul: Add<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.
source§

#### fn add(self, rhs: UInt<Ur, B0>) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<Ul, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B0>where
Ul: Add<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.
source§

#### fn add(self, rhs: UInt<Ur, B1>) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<Ul, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B1>where
Ul: Add<Ur> + Unsigned,
Sum<Ul, Ur>: 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.
source§

#### fn add(self, rhs: UInt<Ur, B1>) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Add<UTerm> for UInt<U, B>

`UInt<U, B> + UTerm = UInt<U, B>`

§

#### type Output = UInt<U, B>

The resulting type after applying the `+` operator.
source§

#### fn add(self, _: UTerm) -> Self::Output

Performs the `+` operation. Read more
source§

### impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitAnd<Ur> for UInt<Ul, Bl>where
UInt<Ul, Bl>: PrivateAnd<Ur>,
PrivateAndOut<UInt<Ul, Bl>, Ur>: 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.
source§

#### fn bitand(self, rhs: Ur) -> Self::Output

Performs the `&` operation. Read more
source§

### impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B0>where
Ul: BitOr<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.
source§

#### fn bitor(self, rhs: UInt<Ur, B0>) -> Self::Output

Performs the `|` operation. Read more
source§

### impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B1>where
Ul: BitOr<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.
source§

#### fn bitor(self, rhs: UInt<Ur, B0>) -> Self::Output

Performs the `|` operation. Read more
source§

### impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B0>where
Ul: BitOr<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.
source§

#### fn bitor(self, rhs: UInt<Ur, B1>) -> Self::Output

Performs the `|` operation. Read more
source§

### impl<Ul, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B1>where
Ul: BitOr<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.
source§

#### fn bitor(self, rhs: UInt<Ur, B1>) -> Self::Output

Performs the `|` operation. Read more
source§

### impl<B: Bit, U: Unsigned> BitOr<UTerm> for UInt<U, B>

`X | UTerm = X`

§

#### type Output = UInt<U, B>

The resulting type after applying the `|` operator.
source§

#### fn bitor(self, _: UTerm) -> Self::Output

Performs the `|` operation. Read more
source§

### impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitXor<Ur> for UInt<Ul, Bl>where
UInt<Ul, Bl>: PrivateXor<Ur>,
PrivateXorOut<UInt<Ul, Bl>, Ur>: 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.
source§

#### fn bitxor(self, rhs: Ur) -> Self::Output

Performs the `^` operation. Read more
source§

### impl<U: Clone, B: Clone> Clone for UInt<U, B>

source§

#### fn clone(&self) -> UInt<U, B>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from `source`. Read more
source§

### impl<U: Unsigned, B: Bit> Cmp<UInt<U, B>> for UTerm

Zero < Nonzero

§

#### type Output = Less

The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`.
source§

### impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B0>where
Ul: PrivateCmp<Ur, Equal> + 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`.
source§

### impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B1>where
Ul: PrivateCmp<Ur, Greater> + 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`.
source§

### impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B0>where
Ul: PrivateCmp<Ur, Less> + 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`.
source§

### impl<Ul, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B1>where
Ul: PrivateCmp<Ur, Equal> + 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`.
source§

### impl<U: Unsigned, B: Bit> Cmp<UTerm> for UInt<U, B>

Nonzero > Zero

§

#### type Output = Greater

The result of the comparison. It should only ever be one of `Greater`, `Less`, or `Equal`.
source§

### impl<U: Debug, B: Debug> Debug for UInt<U, B>

source§

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

Formats the value using the given formatter. Read more
source§

### impl<U: Default, B: Default> Default for UInt<U, B>

source§

#### fn default() -> UInt<U, B>

Returns the “default value” for a type. Read more
source§

### impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UInt<Ul, Bl>where
UInt<Ul, Bl>: Len,
Length<UInt<Ul, Bl>>: Sub<B1>,
(): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>,

§

#### 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.
source§

#### fn div(self, rhs: UInt<Ur, Br>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UTerm

§

#### type Output = UTerm

The resulting type after applying the `/` operator.
source§

#### fn div(self, _: UInt<Ur, Br>) -> Self::Output

Performs the `/` operation. Read more
source§

### impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B0>where
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

§

#### type Output = UInt<<Xp as Gcd<Yp>>::Output, B0>

The greatest common divisor.
source§

### impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B1>where
UInt<Xp, B1>: Gcd<Yp>,
UInt<Yp, B0>: NonZero,

gcd(x, y) = gcd(x, y/2) if x odd and y even

§

#### type Output = <UInt<Xp, B1> as Gcd<Yp>>::Output

The greatest common divisor.
source§

### impl<Xp, Yp> Gcd<UInt<Yp, B1>> for UInt<Xp, B0>where
Xp: Gcd<UInt<Yp, B1>>,
UInt<Xp, B0>: NonZero,

gcd(x, y) = gcd(x/2, y) if x even and y odd

§

#### type Output = <Xp as Gcd<UInt<Yp, B1>>>::Output

The greatest common divisor.
source§

### impl<Xp, Yp> Gcd<UInt<Yp, B1>> for UInt<Xp, B1>where
UInt<Xp, B1>: Max<UInt<Yp, B1>> + Min<UInt<Yp, B1>>,
UInt<Yp, B1>: Max<UInt<Xp, B1>> + Min<UInt<Xp, B1>>,
Maximum<UInt<Xp, B1>, UInt<Yp, B1>>: Sub<Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>,
Diff<Maximum<UInt<Xp, B1>, UInt<Yp, B1>>, Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>: Gcd<Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>,

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.
source§

### impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn>where
UInt<Ui, Bi>: Copy + Sub<B1>,
Un: GetBit<Sub1<UInt<Ui, Bi>>>,

§

#### type Output = <Un as GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>>::Output

source§

### impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn>where
Bn: Copy,

§

#### type Output = Bn

source§

### impl<U: Hash, B: Hash> Hash for UInt<U, B>

source§

#### fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given `Hasher`. Read more
1.3.0 · source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)where
H: Hasher,
Self: Sized,

Feeds a slice of this type into the given `Hasher`. Read more
source§

### impl<U, B: Bit> Len for UInt<U, B>where
U: Len + Unsigned,
Length<U>: Add<B1>,
Add1<Length<U>>: 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.
source§

#### fn len(&self) -> Self::Output

This function isn’t used in this crate, but may be useful for others.
source§

### impl<U, B, Ur> Max<Ur> for UInt<U, B>where
U: Unsigned,
B: Bit,
Ur: Unsigned,
UInt<U, B>: Cmp<Ur> + PrivateMax<Ur, Compare<UInt<U, B>, Ur>>,

§

#### 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`
source§

#### fn max(self, rhs: Ur) -> Self::Output

Method returning the maximum
source§

### impl<U, B, Ur> Min<Ur> for UInt<U, B>where
U: Unsigned,
B: Bit,
Ur: Unsigned,
UInt<U, B>: Cmp<Ur> + PrivateMin<Ur, Compare<UInt<U, B>, Ur>>,

§

#### 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`
source§

#### fn min(self, rhs: Ur) -> Self::Output

Method returning the minimum
source§

### impl<U: Unsigned, B: Bit> Mul<B0> for UInt<U, B>

`UInt * B0 = UTerm`

§

#### type Output = UTerm

The resulting type after applying the `*` operator.
source§

#### fn mul(self, _: B0) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Mul<B1> for UInt<U, B>

`UInt * B1 = UInt`

§

#### type Output = UInt<U, B>

The resulting type after applying the `*` operator.
source§

#### fn mul(self, _: B1) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<Ul, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B0>where
Ul: Mul<UInt<Ur, B>> + 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.
source§

#### fn mul(self, rhs: UInt<Ur, B>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<Ul, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B1>where
Ul: Mul<UInt<Ur, B>> + Unsigned,
UInt<Prod<Ul, UInt<Ur, B>>, 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.
source§

#### fn mul(self, rhs: UInt<Ur, B>) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Mul<UTerm> for UInt<U, B>

`UInt<U, B> * UTerm = UTerm`

§

#### type Output = UTerm

The resulting type after applying the `*` operator.
source§

#### fn mul(self, _: UTerm) -> Self::Output

Performs the `*` operation. Read more
source§

### impl<U: Ord, B: Ord> Ord for UInt<U, B>

source§

#### fn cmp(&self, other: &UInt<U, B>) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere
Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more
source§

### impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl>where
UInt<Ul, Bl>: Div<UInt<Ur, Br>> + Rem<UInt<Ur, Br>, Output = U0>,

§

#### type Output = <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output

The type of the result of the division
source§

#### fn partial_div(self, rhs: UInt<Ur, Br>) -> Self::Output

Method for performing the division
source§

### impl<Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UTerm

§

#### type Output = UTerm

The type of the result of the division
source§

#### fn partial_div(self, _: UInt<Ur, Br>) -> Self::Output

Method for performing the division
source§

### impl<U: PartialEq, B: PartialEq> PartialEq<UInt<U, B>> for UInt<U, B>

source§

#### fn eq(&self, other: &UInt<U, B>) -> bool

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more
1.0.0 · source§

#### fn ne(&self, other: &Rhs) -> bool

This method tests for `!=`. The default implementation is almost always sufficient, and should not be overridden without very good reason. Read more
source§

### impl<U: PartialOrd, B: PartialOrd> PartialOrd<UInt<U, B>> for UInt<U, B>

source§

#### fn partial_cmp(&self, other: &UInt<U, B>) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · source§

#### fn lt(&self, other: &Rhs) -> bool

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · source§

#### fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · source§

#### fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · source§

#### fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f32

§

#### type Output = f32

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f64

§

#### type Output = f64

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i16

§

#### type Output = i16

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i32

§

#### type Output = i32

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i64

§

#### type Output = i64

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i8

§

#### type Output = i8

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for isize

§

#### type Output = isize

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u16

§

#### type Output = u16

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u32

§

#### type Output = u32

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u64

§

#### type Output = u64

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u8

§

#### type Output = u8

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for usize

§

#### type Output = usize

The result of the exponentiation.
source§

#### fn powi(self, _: UInt<U, B>) -> Self::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UInt<Ul, Bl>where
UInt<Ul, Bl>: Len,
Length<UInt<Ul, Bl>>: Sub<B1>,
(): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>,

§

#### 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.
source§

#### fn rem(self, rhs: UInt<Ur, Br>) -> Self::Output

Performs the `%` operation. Read more
source§

### impl<Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UTerm

§

#### type Output = UTerm

The resulting type after applying the `%` operator.
source§

#### fn rem(self, _: UInt<Ur, Br>) -> Self::Output

Performs the `%` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Shl<B0> for UInt<U, B>

Shifting left any unsigned by a zero bit: `U << B0 = U`

§

#### type Output = UInt<U, B>

The resulting type after applying the `<<` operator.
source§

#### fn shl(self, _: B0) -> Self::Output

Performs the `<<` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Shl<B1> for UInt<U, B>

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.
source§

#### fn shl(self, _: B1) -> Self::Output

Performs the `<<` operation. Read more
source§

### impl<U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit> Shl<UInt<Ur, Br>> for UInt<U, B>where
UInt<Ur, Br>: Sub<B1>,
UInt<UInt<U, B>, B0>: Shl<Sub1<UInt<Ur, Br>>>,

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.
source§

#### fn shl(self, rhs: UInt<Ur, Br>) -> Self::Output

Performs the `<<` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Shl<UTerm> for UInt<U, B>

Shifting left `UInt` by `UTerm`: `UInt<U, B> << UTerm = UInt<U, B>`

§

#### type Output = UInt<U, B>

The resulting type after applying the `<<` operator.
source§

#### fn shl(self, _: UTerm) -> Self::Output

Performs the `<<` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Shr<B0> for UInt<U, B>

Shifting right any unsigned by a zero bit: `U >> B0 = U`

§

#### type Output = UInt<U, B>

The resulting type after applying the `>>` operator.
source§

#### fn shr(self, _: B0) -> Self::Output

Performs the `>>` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Shr<B1> for UInt<U, B>

Shifting right a `UInt` by a 1 bit: `UInt<U, B> >> B1 = U`

§

#### type Output = U

The resulting type after applying the `>>` operator.
source§

#### fn shr(self, _: B1) -> Self::Output

Performs the `>>` operation. Read more
source§

### impl<U, B: Bit, Ur: Unsigned, Br: Bit> Shr<UInt<Ur, Br>> for UInt<U, B>where
UInt<Ur, Br>: Sub<B1>,
U: Shr<Sub1<UInt<Ur, Br>>> + Unsigned,

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.
source§

#### fn shr(self, rhs: UInt<Ur, Br>) -> Self::Output

Performs the `>>` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Shr<UTerm> for UInt<U, B>

Shifting right `UInt` by `UTerm`: `UInt<U, B> >> UTerm = UInt<U, B>`

§

#### type Output = UInt<U, B>

The resulting type after applying the `>>` operator.
source§

#### fn shr(self, _: UTerm) -> Self::Output

Performs the `>>` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Sub<B0> for UInt<U, B>

`UInt - B0 = UInt`

§

#### type Output = UInt<U, B>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, _: B0) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<U> Sub<B1> for UInt<U, B0>where
U: Sub<B1> + Unsigned,
Sub1<U>: 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.
source§

#### fn sub(self, _: B1) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<U: Unsigned, B: Bit> Sub<B1> for UInt<UInt<U, B>, B1>

`UInt<U, B1> - B1 = UInt<U, B0>`

§

#### type Output = UInt<UInt<U, B>, B0>

The resulting type after applying the `-` operator.
source§

#### fn sub(self, _: B1) -> Self::Output

Performs the `-` operation. Read more
source§

### impl Sub<B1> for UInt<UTerm, B1>

`UInt<UTerm, B1> - B1 = UTerm`

§

#### type Output = UTerm

The resulting type after applying the `-` operator.
source§

#### fn sub(self, _: B1) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Sub<Ur> for UInt<Ul, Bl>where
UInt<Ul, Bl>: PrivateSub<Ur>,
PrivateSubOut<UInt<Ul, Bl>, Ur>: 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.
source§

#### fn sub(self, rhs: Ur) -> Self::Output

Performs the `-` operation. Read more
source§

### impl<U, B> ToInt<i16> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> i16

Method returning the concrete value for the type.
source§

#### const INT: i16 = Self::I16

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<i32> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> i32

Method returning the concrete value for the type.
source§

#### const INT: i32 = Self::I32

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<i64> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> i64

Method returning the concrete value for the type.
source§

#### const INT: i64 = Self::I64

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<i8> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> i8

Method returning the concrete value for the type.
source§

#### const INT: i8 = Self::I8

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<u16> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> u16

Method returning the concrete value for the type.
source§

#### const INT: u16 = Self::U16

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<u32> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> u32

Method returning the concrete value for the type.
source§

#### const INT: u32 = Self::U32

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<u64> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> u64

Method returning the concrete value for the type.
source§

#### const INT: u64 = Self::U64

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<u8> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> u8

Method returning the concrete value for the type.
source§

#### const INT: u8 = Self::U8

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U, B> ToInt<usize> for UInt<U, B>where
U: Unsigned,
B: Bit,

source§

#### fn to_int() -> usize

Method returning the concrete value for the type.
source§

#### const INT: usize = Self::USIZE

The concrete value for the type. Can be used in `const` contexts.
source§

### impl<U: Unsigned, B: Bit> Unsigned for UInt<U, B>

source§

#### const U8: u8 = _

source§

#### const U16: u16 = _

source§

#### const U32: u32 = _

source§

#### const U64: u64 = _

source§

#### const USIZE: usize = _

source§

#### const I8: i8 = _

source§

#### const I16: i16 = _

source§

#### const I32: i32 = _

source§

#### const I64: i64 = _

source§

#### const ISIZE: isize = _

source§

#### fn to_u8() -> u8

source§

#### fn to_u16() -> u16

source§

#### fn to_u32() -> u32

source§

#### fn to_u64() -> u64

source§

#### fn to_usize() -> usize

source§

#### fn to_i8() -> i8

source§

#### fn to_i16() -> i16

source§

#### fn to_i32() -> i32

source§

#### fn to_i64() -> i64

source§

#### fn to_isize() -> isize

source§

### impl<U: Copy, B: Copy> Copy for UInt<U, B>

source§

### impl<U: Eq, B: Eq> Eq for UInt<U, B>

source§

### impl<U: Unsigned, B: Bit> NonZero for UInt<U, B>

source§

### impl<U: Unsigned + PowerOfTwo> PowerOfTwo for UInt<U, B0>

source§

### impl PowerOfTwo for UInt<UTerm, B1>

source§

### impl<U, B> StructuralEq for UInt<U, B>

source§

### impl<U, B> StructuralPartialEq for UInt<U, B>

## Auto Trait Implementations§

§

### impl<U, B> RefUnwindSafe for UInt<U, B>where
B: RefUnwindSafe,
U: RefUnwindSafe,

§

### impl<U, B> Send for UInt<U, B>where
B: Send,
U: Send,

§

### impl<U, B> Sync for UInt<U, B>where
B: Sync,
U: Sync,

§

### impl<U, B> Unpin for UInt<U, B>where
B: Unpin,
U: Unpin,

§

### impl<U, B> UnwindSafe for UInt<U, B>where
B: UnwindSafe,
U: UnwindSafe,

## Blanket Implementations§

source§

### impl<T> Any for Twhere
T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

const: unstable · source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<X> Gcd<UTerm> for Xwhere
X: Unsigned + NonZero,

§

#### type Output = X

The greatest common divisor.
source§

### impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<N> Logarithm2 for Nwhere
N: PrivateLogarithm2,

§

#### type Output = <N as PrivateLogarithm2>::Output

The result of the integer binary logarithm.
source§

### impl<X, N> Pow<N> for Xwhere
X: Unsigned + PrivatePow<UInt<UTerm, B1>, N>,
N: Unsigned,

§

#### type Output = <X as PrivatePow<UInt<UTerm, B1>, N>>::Output

The result of the exponentiation.
source§

#### fn powi(self, n: N) -> <X as Pow<N>>::Output

This function isn’t used in this crate, but may be useful for others. It is implemented for primitives. Read more
source§

### impl<T> Same<T> for T

§

#### type Output = T

Should always be `Self`
source§

### impl<N, I, B> SetBit<I, B> for Nwhere
N: PrivateSetBit<I, B>,
<N as PrivateSetBit<I, B>>::Output: Trim,

§

#### type Output = <<N as PrivateSetBit<I, B>>::Output as Trim>::Output

source§

#### fn set_bit<IM>(self, i: I, b: B) -> <N as SetBit<I, B>>::Output where
IM: InternalMarker,

source§

### impl<N> SquareRoot for Nwhere
N: PrivateSquareRoot,

§

#### type Output = <N as PrivateSquareRoot>::Output

The result of the integer square root.
source§

### impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
const: unstable · source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.