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

pub struct UInt<U, B> {
    // some 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, Unsigned};

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

Trait Implementations

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

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

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

fn hash<__HUB: Hasher>(&self, __arg_0: &mut __HUB)

Feeds this value into the state given, updating the hasher as necessary.

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

Feeds a slice of this type into the state provided.

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

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

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

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

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

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

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

fn lt(&self, __arg_0: &UInt<U, B>) -> bool

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

fn le(&self, __arg_0: &UInt<U, B>) -> bool

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

fn gt(&self, __arg_0: &UInt<U, B>) -> bool

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

fn ge(&self, __arg_0: &UInt<U, B>) -> bool

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

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

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

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

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

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

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

fn ne(&self, __arg_0: &UInt<U, B>) -> bool

This method tests for !=.

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

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

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

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

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

The method for the + operator

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

The method for the + operator

impl<U: Unsigned> Add<B1> for UInt<U, B1> where U: Add<B1>, Sum<U, B1>: 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

The method for the + operator

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

The method for the + operator

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, _: UInt<Ur, B0>) -> Self::Output

The method for the + operator

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, _: UInt<Ur, B1>) -> Self::Output

The method for the + operator

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, _: UInt<Ur, B0>) -> Self::Output

The method for the + operator

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, _: UInt<Ur, B1>) -> Self::Output

The method for the + operator

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

The method for the - operator

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

The method for the - operator

impl Sub<B1> for UInt<UTermB1>
[src]

UInt<UTerm, B1> - B1 = UTerm

type Output = UTerm

The resulting type after applying the - operator

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

The method for the - operator

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

The method for the - operator

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, _: Ur) -> Self::Output

The method for the - operator

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, _: Ur) -> Self::Output

The method for the & operator

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

The method for the | operator

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::Output, B0>

The resulting type after applying the | operator

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

The method for the | operator

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, _: UInt<Ur, B1>) -> Self::Output

The method for the | operator

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, _: UInt<Ur, B0>) -> Self::Output

The method for the | operator

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, _: UInt<Ur, B1>) -> Self::Output

The method for the | operator

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, _: Ur) -> Self::Output

The method for the ^ operator

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

The method for the << operator

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

The method for the << operator

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

The method for the << operator

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, _: UInt<Ur, Br>) -> Self::Output

The method for the << operator

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

The method for the >> operator

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

The method for the >> operator

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

The method for the >> operator

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, _: UInt<Ur, Br>) -> Self::Output

The method for the >> operator

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

The method for the * operator

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

The method for the * operator

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

The method for the * operator

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, _: UInt<Ur, B>) -> Self::Output

The method for the * operator

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, _: UInt<Ur, B>) -> Self::Output

The method for the * operator

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.

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.

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.

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.

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.

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Div<Ur> for UInt<Ul, Bl> where UInt<Ul, Bl>: Cmp<Ur>, UInt<Ul, Bl>: PrivateDivFirstStep<Compare<UInt<Ul, Bl>, Ur>, Ur>
[src]

type Output = PrivateDivFirstStepQuot<UInt<Ul, Bl>, Compare<UInt<Ul, Bl>, Ur>, Ur>

The resulting type after applying the / operator

fn div(self, _: Ur) -> Self::Output

The method for the / operator

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Rem<Ur> for UInt<Ul, Bl> where UInt<Ul, Bl>: Cmp<Ur>, UInt<Ul, Bl>: PrivateDivFirstStep<Compare<UInt<Ul, Bl>, Ur>, Ur>
[src]

type Output = PrivateDivFirstStepRem<UInt<Ul, Bl>, Compare<UInt<Ul, Bl>, Ur>, Ur>

The resulting type after applying the % operator

fn rem(self, _: Ur) -> Self::Output

The method for the % operator