# [−] [src] Struct typenum::uint::UInt

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

`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: Unsigned, B: Bit> UInt<U, B>` [src]

#### `pub fn new() -> UInt<U, B>` [src]

Instantiates a singleton representing this unsigned integer.

## Trait Implementations

### `impl<U: Unsigned, B: Bit> Add<B0> for UInt<U, B>` [src]

`U + B0 = U`

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

The resulting type after applying the `+` operator.

#### `fn add(self, _: B0) -> Self::Output` [src]

Performs the `+` operation. Read more

### `impl<U: Unsigned> Add<B1> for UInt<U, B0>` [src]

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

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

The resulting type after applying the `+` operator.

#### `fn add(self, _: B1) -> Self::Output` [src]

Performs the `+` operation. Read more

### `impl<U: Unsigned> Add<B1> for UInt<U, B1> where
U: Add<B1>,
Add1<U>: Unsigned,` [src]

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

#### `type Output = UInt<Add1<U>, B0>`

The resulting type after applying the `+` operator.

#### `fn add(self, _: B1) -> Self::Output` [src]

Performs the `+` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: Add<Ur>,` [src]

`UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>`

#### `type Output = UInt<Sum<Ul, Ur>, B0>`

The resulting type after applying the `+` operator.

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

Performs the `+` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: Add<Ur>,` [src]

`UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>`

#### `type Output = UInt<Sum<Ul, Ur>, B1>`

The resulting type after applying the `+` operator.

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

Performs the `+` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: Add<Ur>,` [src]

`UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>`

#### `type Output = UInt<Sum<Ul, Ur>, B1>`

The resulting type after applying the `+` operator.

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

Performs the `+` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: Add<Ur>,
Sum<Ul, Ur>: Add<B1>,` [src]

`UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>`

#### `type Output = UInt<Add1<Sum<Ul, Ur>>, B0>`

The resulting type after applying the `+` operator.

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

Performs the `+` operation. Read more

### `impl<U: Unsigned, B: Bit> Add<UTerm> for UInt<U, B>` [src]

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

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

The resulting type after applying the `+` operator.

#### `fn add(self, _: UTerm) -> Self::Output` [src]

Performs the `+` operation. Read more

### `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,` [src]

Anding unsigned integers. We use our `PrivateAnd` operator and then `Trim` the output.

#### `type Output = TrimOut<PrivateAndOut<UInt<Ul, Bl>, Ur>>`

The resulting type after applying the `&` operator.

#### `fn bitand(self, rhs: Ur) -> Self::Output` [src]

Performs the `&` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: BitOr<Ur>,` [src]

`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>) -> Self::Output` [src]

Performs the `|` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: BitOr<Ur>,` [src]

`UInt<Ul, B1> | UInt<Ur, B0> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<Or<Ul, Ur>, B1>`

The resulting type after applying the `|` operator.

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

Performs the `|` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: BitOr<Ur>,` [src]

`UInt<Ul, B0> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<Or<Ul, Ur>, B1>`

The resulting type after applying the `|` operator.

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

Performs the `|` operation. Read more

### `impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: BitOr<Ur>,` [src]

`UInt<Ul, B1> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`

#### `type Output = UInt<Or<Ul, Ur>, B1>`

The resulting type after applying the `|` operator.

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

Performs the `|` operation. Read more

### `impl<B: Bit, U: Unsigned> BitOr<UTerm> for UInt<U, B>` [src]

`X | UTerm = X`

#### `type Output = Self`

The resulting type after applying the `|` operator.

#### `fn bitor(self, _: UTerm) -> Self::Output` [src]

Performs the `|` operation. Read more

### `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,` [src]

Xoring unsigned integers. We use our `PrivateXor` operator and then `Trim` the output.

#### `type Output = TrimOut<PrivateXorOut<UInt<Ul, Bl>, Ur>>`

The resulting type after applying the `^` operator.

#### `fn bitxor(self, rhs: Ur) -> Self::Output` [src]

Performs the `^` operation. Read more

### `impl<U: Clone, B: Clone> Clone for UInt<U, B>` [src]

#### `fn clone(&self) -> UInt<U, B>` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl<U: Unsigned, B: Bit> Cmp<UInt<U, B>> for UTerm` [src]

Zero < Nonzero

#### `type Output = Less`

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

#### `fn compare<IM: InternalMarker>(&self, _: &UInt<U, B>) -> Self::Output` [src]

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B0> where
Ul: PrivateCmp<Ur, Equal>,` [src]

`UInt<Ul, B0>` cmp with `UInt<Ur, B0>`: `SoFar` is `Equal`

#### `type Output = PrivateCmpOut<Ul, Ur, Equal>`

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

#### `fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B0>) -> Self::Output` [src]

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B1> where
Ul: PrivateCmp<Ur, Greater>,` [src]

`UInt<Ul, B1>` cmp with `UInt<Ur, B0>`: `SoFar` is `Greater`

#### `type Output = PrivateCmpOut<Ul, Ur, Greater>`

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

#### `fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B0>) -> Self::Output` [src]

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B1> where
Ul: PrivateCmp<Ur, Equal>,` [src]

`UInt<Ul, B1>` cmp with `UInt<Ur, B1>`: `SoFar` is `Equal`

#### `type Output = PrivateCmpOut<Ul, Ur, Equal>`

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

#### `fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B1>) -> Self::Output` [src]

### `impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B0> where
Ul: PrivateCmp<Ur, Less>,` [src]

`UInt<Ul, B0>` cmp with `UInt<Ur, B1>`: `SoFar` is `Less`

#### `type Output = PrivateCmpOut<Ul, Ur, Less>`

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

#### `fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B1>) -> Self::Output` [src]

### `impl<U: Unsigned, B: Bit> Cmp<UTerm> for UInt<U, B>` [src]

Nonzero > Zero

#### `type Output = Greater`

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

#### `fn compare<IM: InternalMarker>(&self, _: &UTerm) -> Self::Output` [src]

### `impl<U: Copy, B: Copy> Copy for UInt<U, B>` [src]

### `impl<U: Debug, B: Debug> Debug for UInt<U, B>` [src]

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

Formats the value using the given formatter. Read more

### `impl<U: Default, B: Default> Default for UInt<U, B>` [src]

#### `fn default() -> UInt<U, B>` [src]

Returns the "default value" for a type. Read more

### `impl<Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UTerm` [src]

#### `type Output = UTerm`

The resulting type after applying the `/` operator.

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

Performs the `/` operation. Read more

### `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>>>>,` [src]

#### `type Output = PrivateDivQuot<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>`

The resulting type after applying the `/` operator.

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

Performs the `/` operation. Read more

### `impl<U: Eq, B: Eq> Eq for UInt<U, B>` [src]

### `impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B0> where
Xp: Gcd<Yp>,
UInt<Xp, B0>: NonZero,
UInt<Yp, B0>: NonZero,` [src]

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

#### `type Output = UInt<Gcf<Xp, Yp>, B0>`

The greatest common divisor.

### `impl<Xp, Yp> Gcd<UInt<Yp, B0>> for UInt<Xp, B1> where
UInt<Xp, B1>: Gcd<Yp>,
UInt<Yp, B0>: NonZero,` [src]

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

#### `type Output = Gcf<UInt<Xp, B1>, Yp>`

The greatest common divisor.

### `impl<Xp, Yp> Gcd<UInt<Yp, B1>> for UInt<Xp, B0> where
Xp: Gcd<UInt<Yp, B1>>,
UInt<Xp, B0>: NonZero,` [src]

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

#### `type Output = Gcf<Xp, UInt<Yp, B1>>`

The greatest common divisor.

### `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>>>,` [src]

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 = Gcf<Diff<Maximum<UInt<Xp, B1>, UInt<Yp, B1>>, Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>, Minimum<UInt<Xp, B1>, UInt<Yp, B1>>>`

The greatest common divisor.

### `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>>>,` [src]

#### `type Output = GetBitOut<Un, Sub1<UInt<Ui, Bi>>>`

#### `fn get_bit<IM: InternalMarker>(&self, i: &UInt<Ui, Bi>) -> Self::Output` [src]

### `impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn> where
Bn: Copy,` [src]

#### `type Output = Bn`

#### `fn get_bit<IM: InternalMarker>(&self, _: &U0) -> Self::Output` [src]

### `impl<U: Hash, B: Hash> Hash for UInt<U, B>` [src]

#### `fn hash<__H: Hasher>(&self, state: &mut __H)` [src]

Feeds this value into the given `Hasher`. Read more

#### `pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0 [src]

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

### `impl<U: Unsigned, B: Bit> Len for UInt<U, B> where
U: Len,
Length<U>: Add<B1>,
Add1<Length<U>>: Unsigned,` [src]

Length of a bit is 1

#### `type Output = Add1<Length<U>>`

The length as a type-level unsigned integer.

#### `fn len(&self) -> Self::Output` [src]

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

### `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>>,` [src]

#### `type Output = PrivateMaxOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>`

The type of the maximum of `Self` and `Rhs`

#### `fn max(self, rhs: Ur) -> Self::Output` [src]

Method returning the maximum

### `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>>,` [src]

#### `type Output = PrivateMinOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>`

The type of the minimum of `Self` and `Rhs`

#### `fn min(self, rhs: Ur) -> Self::Output` [src]

Method returning the minimum

### `impl<U: Unsigned, B: Bit> Mul<B0> for UInt<U, B>` [src]

`UInt * B0 = UTerm`

#### `type Output = UTerm`

The resulting type after applying the `*` operator.

#### `fn mul(self, _: B0) -> Self::Output` [src]

Performs the `*` operation. Read more

### `impl<U: Unsigned, B: Bit> Mul<B1> for UInt<U, B>` [src]

`UInt * B1 = UInt`

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

The resulting type after applying the `*` operator.

#### `fn mul(self, _: B1) -> Self::Output` [src]

Performs the `*` operation. Read more

### `impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B0> where
Ul: Mul<UInt<Ur, B>>,` [src]

`UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>`

#### `type Output = UInt<Prod<Ul, UInt<Ur, B>>, B0>`

The resulting type after applying the `*` operator.

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

Performs the `*` operation. Read more

### `impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B1> where
Ul: Mul<UInt<Ur, B>>,
UInt<Prod<Ul, UInt<Ur, B>>, B0>: Add<UInt<Ur, B>>,` [src]

`UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>`

#### `type Output = Sum<UInt<Prod<Ul, UInt<Ur, B>>, B0>, UInt<Ur, B>>`

The resulting type after applying the `*` operator.

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

Performs the `*` operation. Read more

### `impl<U: Unsigned, B: Bit> Mul<UTerm> for UInt<U, B>` [src]

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

#### `type Output = UTerm`

The resulting type after applying the `*` operator.

#### `fn mul(self, _: UTerm) -> Self::Output` [src]

Performs the `*` operation. Read more

### `impl<U: Unsigned, B: Bit> NonZero for UInt<U, B>` [src]

### `impl<U: Ord, B: Ord> Ord for UInt<U, B>` [src]

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

This method returns an `Ordering` between `self` and `other`. Read more

#### `#[must_use]pub fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]pub fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self` 1.50.0 [src]

Restrict a value to a certain interval. Read more

### `impl<Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UTerm` [src]

#### `type Output = UTerm`

The type of the result of the division

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

Method for performing the division

### `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>,` [src]

#### `type Output = Quot<UInt<Ul, Bl>, UInt<Ur, Br>>`

The type of the result of the division

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

Method for performing the division

### `impl<U: PartialEq, B: PartialEq> PartialEq<UInt<U, B>> for UInt<U, B>` [src]

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

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

#### `fn ne(&self, other: &UInt<U, B>) -> bool` [src]

This method tests for `!=`.

### `impl<U: PartialOrd, B: PartialOrd> PartialOrd<UInt<U, B>> for UInt<U, B>` [src]

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

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

#### `fn lt(&self, other: &UInt<U, B>) -> bool` [src]

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

#### `fn le(&self, other: &UInt<U, B>) -> bool` [src]

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

#### `fn gt(&self, other: &UInt<U, B>) -> bool` [src]

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

#### `fn ge(&self, other: &UInt<U, B>) -> bool` [src]

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f32` [src]

#### `type Output = f32`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f64` [src]

#### `type Output = f64`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i64` [src]

#### `type Output = i64`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for isize` [src]

#### `type Output = isize`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u8` [src]

#### `type Output = u8`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u16` [src]

#### `type Output = u16`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u32` [src]

#### `type Output = u32`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u64` [src]

#### `type Output = u64`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for usize` [src]

#### `type Output = usize`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i8` [src]

#### `type Output = i8`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i16` [src]

#### `type Output = i16`

The result of the exponentiation.

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

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

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i32` [src]

#### `type Output = i32`

The result of the exponentiation.

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

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

### `impl PowerOfTwo for UInt<UTerm, B1>` [src]

### `impl<U: Unsigned + PowerOfTwo> PowerOfTwo for UInt<U, B0>` [src]

### `impl<Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UTerm` [src]

#### `type Output = UTerm`

The resulting type after applying the `%` operator.

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

Performs the `%` operation. Read more

### `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>>>>,` [src]

#### `type Output = PrivateDivRem<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>`

The resulting type after applying the `%` operator.

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

Performs the `%` operation. Read more

### `impl<U: Unsigned, B: Bit> Shl<B0> for UInt<U, B>` [src]

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) -> Self::Output` [src]

Performs the `<<` operation. Read more

### `impl<U: Unsigned, B: Bit> Shl<B1> for UInt<U, B>` [src]

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) -> Self::Output` [src]

Performs the `<<` operation. Read more

### `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>>>,` [src]

Shifting left `UInt` by `UInt`: `X << Y` = `UInt(X, B0) << (Y - 1)`

#### `type Output = Shleft<UInt<UInt<U, B>, B0>, Sub1<UInt<Ur, Br>>>`

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

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

Performs the `<<` operation. Read more

### `impl<U: Unsigned, B: Bit> Shl<UTerm> for UInt<U, B>` [src]

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) -> Self::Output` [src]

Performs the `<<` operation. Read more

### `impl<U: Unsigned, B: Bit> Shr<B0> for UInt<U, B>` [src]

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) -> Self::Output` [src]

Performs the `>>` operation. Read more

### `impl<U: Unsigned, B: Bit> Shr<B1> for UInt<U, B>` [src]

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) -> Self::Output` [src]

Performs the `>>` operation. Read more

### `impl<U: Unsigned, 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>>>,` [src]

Shifting right `UInt` by `UInt`: `UInt(U, B) >> Y` = `U >> (Y - 1)`

#### `type Output = Shright<U, Sub1<UInt<Ur, Br>>>`

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

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

Performs the `>>` operation. Read more

### `impl<U: Unsigned, B: Bit> Shr<UTerm> for UInt<U, B>` [src]

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) -> Self::Output` [src]

Performs the `>>` operation. Read more

### `impl<U, B> StructuralEq for UInt<U, B>` [src]

### `impl<U, B> StructuralPartialEq for UInt<U, B>` [src]

### `impl<U: Unsigned, B: Bit> Sub<B0> for UInt<U, B>` [src]

`UInt - B0 = UInt`

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

The resulting type after applying the `-` operator.

#### `fn sub(self, _: B0) -> Self::Output` [src]

Performs the `-` operation. Read more

### `impl<U: Unsigned, B: Bit> Sub<B1> for UInt<UInt<U, B>, B1>` [src]

`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) -> Self::Output` [src]

Performs the `-` operation. Read more

### `impl Sub<B1> for UInt<UTerm, B1>` [src]

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

#### `type Output = UTerm`

The resulting type after applying the `-` operator.

#### `fn sub(self, _: B1) -> Self::Output` [src]

Performs the `-` operation. Read more

### `impl<U: Unsigned> Sub<B1> for UInt<U, B0> where
U: Sub<B1>,
Sub1<U>: Unsigned,` [src]

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

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

The resulting type after applying the `-` operator.

#### `fn sub(self, _: B1) -> Self::Output` [src]

Performs the `-` operation. Read more

### `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,` [src]

Subtracting unsigned integers. We just do our `PrivateSub` and then `Trim` the output.

#### `type Output = TrimOut<PrivateSubOut<UInt<Ul, Bl>, Ur>>`

The resulting type after applying the `-` operator.

#### `fn sub(self, rhs: Ur) -> Self::Output` [src]

Performs the `-` operation. Read more

### `impl<U: Unsigned, B: Bit> Unsigned for UInt<U, B>` [src]

#### `const U8: u8` [src]

#### `const U16: u16` [src]

#### `const U32: u32` [src]

#### `const U64: u64` [src]

#### `const USIZE: usize` [src]

#### `const I8: i8` [src]

#### `const I16: i16` [src]

#### `const I32: i32` [src]

#### `const I64: i64` [src]

#### `const ISIZE: isize` [src]

#### `fn to_u8() -> u8` [src]

#### `fn to_u16() -> u16` [src]

#### `fn to_u32() -> u32` [src]

#### `fn to_u64() -> u64` [src]

#### `fn to_usize() -> usize` [src]

#### `fn to_i8() -> i8` [src]

#### `fn to_i16() -> i16` [src]

#### `fn to_i32() -> i32` [src]

#### `fn to_i64() -> i64` [src]

#### `fn to_isize() -> isize` [src]

## Auto Trait Implementations

### `impl<U, B> Send for UInt<U, B> where
B: Send,
U: Send,` [src]

### `impl<U, B> Sync for UInt<U, B> where
B: Sync,
U: Sync,` [src]

### `impl<U, B> Unpin for UInt<U, B> where
B: Unpin,
U: Unpin,` [src]

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

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

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<X> Gcd<UTerm> for X where
X: Unsigned + NonZero,` [src]

#### `type Output = X`

The greatest common divisor.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<N> Logarithm2 for N where
N: PrivateLogarithm2,` [src]

#### `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]

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

The result of the exponentiation.

#### `pub fn powi(Self, N) -> <X as Pow<N>>::Output` [src]

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

### `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]

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

#### `pub fn set_bit<IM>(Self, I, B) -> <N as SetBit<I, B>>::Output where
IM: InternalMarker,` [src]

### `impl<N> SquareRoot for N where
N: PrivateSquareRoot,` [src]

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

The result of the integer square root.

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `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]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `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]

Performs the conversion.