Struct typenum::uint::UInt

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

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

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

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

type Output = UInt<U, B1>

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

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>

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

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

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

type Output = UInt<U, B>

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

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>

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

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>

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

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>

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

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>

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

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

UInt - B0 = UInt

type Output = UInt<U, B>

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

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>

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

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

UInt<UTerm, B1> - B1 = UTerm

type Output = UTerm

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

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>

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

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

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

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

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

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

X | UTerm = X

type Output = Self

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

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>

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

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>

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

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>

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

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>

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

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

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

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>

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

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>

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

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>

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

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

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

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>

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

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>

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

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

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

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

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

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

UInt * B0 = UTerm

type Output = UTerm

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

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

UInt * B1 = UInt

type Output = UInt<U, B>

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

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

UInt<U, B> * UTerm = UTerm

type Output = UTerm

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

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>

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

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

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

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

Nonzero > Zero

type Output = Greater

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>

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

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

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

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

Derived Implementations

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

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

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

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

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

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>

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

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

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

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

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

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

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

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

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

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

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

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

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