Struct typenum::uint::UInt

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

Trait Implementations

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

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>

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

Feeds a slice of this type into the state provided.

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

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

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

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

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.

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

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

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.

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

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

This method returns an Ordering between self and other.

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

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

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

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

This method tests for !=.

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

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

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>

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

UInt + B0 = UInt

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>

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

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>

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>

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>

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>

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>

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>

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>

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<UTerm, B1>

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

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

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

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>

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>

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>

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>

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>

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

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>

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>

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>

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>>>

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>

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>

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>

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>>>

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>

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>

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>

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>>

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>>

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>

Nonzero > Zero

type Output = Greater

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

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Cmp<UInt<Ur, Br>> for UInt<Ul, Bl> where UInt<Ul, Bl>: PrivateCmp<UInt<Ur, Br>, Equal>

type Output = PrivateCmpOut<UInt<Ul, Bl>, UInt<Ur, Br>, Equal>

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

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UInt<Ul, Bl> where UInt<Ul, Bl>: Cmp<UInt<Ur, Br>>, UInt<Ul, Bl>: PrivateDivFirstStep<UInt<Ul, Bl>::Output, UInt<Ur, Br>>

type Output = UInt<Ul, Bl>::Quotient

The resulting type after applying the / operator

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

The method for the / operator

impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UInt<Ul, Bl> where UInt<Ul, Bl>: Cmp<UInt<Ur, Br>>, UInt<Ul, Bl>: PrivateDivFirstStep<UInt<Ul, Bl>::Output, UInt<Ur, Br>>

type Output = UInt<Ul, Bl>::Remainder

The resulting type after applying the % operator

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

The method for the % operator