Struct diffgeom::typenum::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>;

Methods

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

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

Instantiates a singleton representing this unsigned integer.

Trait Implementations

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

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, B> Cmp<UTerm> for UInt<U, B> where
    B: Bit,
    U: Unsigned, 

Nonzero > Zero

type Output = Greater

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

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

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

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

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

impl<Ul, Ur> Add<UInt<Ur, B0>> for UInt<Ul, B0> where
    Ul: Unsigned + Add<Ur>,
    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

fn add(self, UInt<Ur, B0>) -> <UInt<Ul, B0> as Add<UInt<Ur, B0>>>::Output

The method for the + operator

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

fn add(self, UInt<Ur, B0>) -> <UInt<Ul, B1> as Add<UInt<Ur, B0>>>::Output

The method for the + operator

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

fn add(self, B1) -> <UInt<U, B1> as Add<B1>>::Output

The method for the + operator

impl<Ul, Ur> Add<UInt<Ur, B1>> for UInt<Ul, B1> where
    Ul: Unsigned + Add<Ur>,
    Ur: Unsigned,
    <Ul as Add<Ur>>::Output: 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

fn add(self, UInt<Ur, B1>) -> <UInt<Ul, B1> as Add<UInt<Ur, B1>>>::Output

The method for the + operator

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

fn add(self, UInt<Ur, B1>) -> <UInt<Ul, B0> as Add<UInt<Ur, B1>>>::Output

The method for the + operator

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

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

type Output = UInt<U, B1>

The resulting type after applying the + operator

fn add(self, B1) -> <UInt<U, B0> as Add<B1>>::Output

The method for the + operator

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

U + B0 = U

type Output = UInt<U, B>

The resulting type after applying the + operator

fn add(self, B0) -> <UInt<U, B> as Add<B0>>::Output

The method for the + operator

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

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

type Output = UInt<U, B>

The resulting type after applying the + operator

fn add(self, UTerm) -> <UInt<U, B> as Add<UTerm>>::Output

The method for the + operator

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

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

type Output = U

fn shr(self, B1) -> <UInt<U, B> as Shr<B1>>::Output

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

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

type Output = UInt<U, B>

fn shr(self, B0) -> <UInt<U, B> as Shr<B0>>::Output

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

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

fn shr(self, UInt<Ur, Br>) -> <UInt<U, B> as Shr<UInt<Ur, Br>>>::Output

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

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

type Output = UInt<U, B>

fn shr(self, UTerm) -> <UInt<U, B> as Shr<UTerm>>::Output

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

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

Formats the value using the given formatter.

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

impl<Ul, Bl, Ur> BitXor<Ur> for UInt<Ul, Bl> where
    Bl: Bit,
    Ul: Unsigned,
    Ur: Unsigned,
    UInt<Ul, Bl>: PrivateXor<Ur>,
    <UInt<Ul, Bl> as PrivateXor<Ur>>::Output: 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

fn bitxor(self, Ur) -> <UInt<Ul, Bl> as BitXor<Ur>>::Output

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

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

fn shl(self, UInt<Ur, Br>) -> <UInt<U, B> as Shl<UInt<Ur, Br>>>::Output

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

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) -> <UInt<U, B> as Shl<B1>>::Output

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

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

type Output = UInt<U, B>

fn shl(self, B0) -> <UInt<U, B> as Shl<B0>>::Output

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

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

type Output = UInt<U, B>

fn shl(self, UTerm) -> <UInt<U, B> as Shl<UTerm>>::Output

impl<U, B, Ur> Min<Ur> for UInt<U, B> where
    B: Bit,
    U: Unsigned,
    Ur: Unsigned,
    UInt<U, B>: Cmp<Ur>,
    UInt<U, B>: PrivateMin<Ur, <UInt<U, B> as Cmp<Ur>>::Output>, 

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

fn min(self, rhs: Ur) -> <UInt<U, B> as Min<Ur>>::Output

Method returning the minimum

impl<U, B> Len for UInt<U, B> where
    B: Bit,
    U: Unsigned + Len,
    <U as Len>::Output: Add<B1>,
    <<U as Len>::Output as Add<B1>>::Output: 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.

fn len(&self) -> <UInt<U, B> as Len>::Output

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

impl<Ul, Bl, Ur, Br> Rem<UInt<Ur, Br>> for UInt<Ul, Bl> where
    Bl: Bit,
    Br: Bit,
    Ul: Unsigned,
    Ur: Unsigned,
    UInt<Ul, Bl>: Len,
    <UInt<Ul, Bl> as Len>::Output: Sub<B1>,
    (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>, 

type Output = <() as PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>>::Remainder

fn rem(self, UInt<Ur, Br>) -> <UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output

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

fn mul(self, UInt<Ur, B>) -> <UInt<Ul, B0> as Mul<UInt<Ur, B>>>::Output

The method for the * operator

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

UInt<U, B> * UTerm = UTerm

type Output = UTerm

The resulting type after applying the * operator

fn mul(self, UTerm) -> <UInt<U, B> as Mul<UTerm>>::Output

The method for the * operator

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

UInt * B0 = UTerm

type Output = UTerm

The resulting type after applying the * operator

fn mul(self, B0) -> <UInt<U, B> as Mul<B0>>::Output

The method for the * operator

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

UInt * B1 = UInt

type Output = UInt<U, B>

The resulting type after applying the * operator

fn mul(self, B1) -> <UInt<U, B> as Mul<B1>>::Output

The method for the * operator

impl<Ul, B, Ur> Mul<UInt<Ur, B>> for UInt<Ul, B1> where
    B: Bit,
    Ul: Unsigned + Mul<UInt<Ur, B>>,
    Ur: Unsigned,
    UInt<<Ul as Mul<UInt<Ur, B>>>::Output, 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

fn mul(self, UInt<Ur, B>) -> <UInt<Ul, B1> as Mul<UInt<Ur, B>>>::Output

The method for the * operator

impl<Un, Bn> GetBit<UTerm> for UInt<Un, Bn>

type Output = Bn

impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn> where
    Un: GetBit<<UInt<Ui, Bi> as Sub<B1>>::Output>,
    UInt<Ui, Bi>: Sub<B1>, 

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

impl<Ul, Bl, Ur, Br> Div<UInt<Ur, Br>> for UInt<Ul, Bl> where
    Bl: Bit,
    Br: Bit,
    Ul: Unsigned,
    Ur: Unsigned,
    UInt<Ul, Bl>: Len,
    <UInt<Ul, Bl> as Len>::Output: Sub<B1>,
    (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, UTerm, UTerm, <<UInt<Ul, Bl> as Len>::Output as Sub<B1>>::Output>, 

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

fn div(self, UInt<Ur, Br>) -> <UInt<Ul, Bl> as Div<UInt<Ur, Br>>>::Output

The method for the / operator

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

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, B> Default for UInt<U, B> where
    B: Default,
    U: Default, 

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

impl<Ul, Ur> BitOr<UInt<Ur, B1>> for UInt<Ul, B0> where
    Ul: Unsigned + BitOr<Ur>,
    Ur: Unsigned, 

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

type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>

fn bitor(self, UInt<Ur, B1>) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B1>>>::Output

impl<Ul, Ur> BitOr<UInt<Ur, B1>> for UInt<Ul, B1> where
    Ul: Unsigned + BitOr<Ur>,
    Ur: Unsigned, 

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

type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>

fn bitor(self, UInt<Ur, B1>) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B1>>>::Output

impl<Ul, Ur> BitOr<UInt<Ur, B0>> for UInt<Ul, B0> where
    Ul: Unsigned + BitOr<Ur>,
    Ur: Unsigned, 

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

type Output = UInt<<Ul as BitOr<Ur>>::Output, B0>

fn bitor(self, UInt<Ur, B0>) -> <UInt<Ul, B0> as BitOr<UInt<Ur, B0>>>::Output

impl<Ul, Ur> BitOr<UInt<Ur, B0>> for UInt<Ul, B1> where
    Ul: Unsigned + BitOr<Ur>,
    Ur: Unsigned, 

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

type Output = UInt<<Ul as BitOr<Ur>>::Output, B1>

fn bitor(self, UInt<Ur, B0>) -> <UInt<Ul, B1> as BitOr<UInt<Ur, B0>>>::Output

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

X | UTerm = X

type Output = UInt<U, B>

fn bitor(self, UTerm) -> <UInt<U, B> as BitOr<UTerm>>::Output

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

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

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, B> Hash for UInt<U, B> where
    B: Hash,
    U: Hash, 

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

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

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, B, Ur> Max<Ur> for UInt<U, B> where
    B: Bit,
    U: Unsigned,
    Ur: Unsigned,
    UInt<U, B>: Cmp<Ur>,
    UInt<U, B>: PrivateMax<Ur, <UInt<U, B> as Cmp<Ur>>::Output>, 

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

fn max(self, rhs: Ur) -> <UInt<U, B> as Max<Ur>>::Output

Method returning the maximum

impl<Ul, Bl, Ur, Br> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl> where
    Bl: Bit,
    Br: Bit,
    Ul: Unsigned,
    Ur: Unsigned,
    UInt<Ul, Bl>: Div<UInt<Ur, Br>>,
    UInt<Ul, Bl>: Rem<UInt<Ur, Br>>,
    <UInt<Ul, Bl> as Rem<UInt<Ur, Br>>>::Output == UTerm, 

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

The type of the result of the division

fn partial_div(
    self,
    UInt<Ur, Br>
) -> <UInt<Ul, Bl> as PartialDiv<UInt<Ur, Br>>>::Output

Method for performing the division

impl<Ul, Bl, Ur> BitAnd<Ur> for UInt<Ul, Bl> where
    Bl: Bit,
    Ul: Unsigned,
    Ur: Unsigned,
    UInt<Ul, Bl>: PrivateAnd<Ur>,
    <UInt<Ul, Bl> as PrivateAnd<Ur>>::Output: 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

fn bitand(self, Ur) -> <UInt<Ul, Bl> as BitAnd<Ur>>::Output

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

UInt - B0 = UInt

type Output = UInt<U, B>

The resulting type after applying the - operator

fn sub(self, B0) -> <UInt<U, B> as Sub<B0>>::Output

The method for the - operator

impl<Ul, Bl, Ur> Sub<Ur> for UInt<Ul, Bl> where
    Bl: Bit,
    Ul: Unsigned,
    Ur: Unsigned,
    UInt<Ul, Bl>: PrivateSub<Ur>,
    <UInt<Ul, Bl> as PrivateSub<Ur>>::Output: 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

fn sub(self, Ur) -> <UInt<Ul, Bl> as Sub<Ur>>::Output

The method for the - operator

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

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) -> <UInt<UInt<U, B>, B1> as Sub<B1>>::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) -> <UInt<UTerm, B1> as Sub<B1>>::Output

The method for the - operator

impl<U> Sub<B1> for UInt<U, B0> where
    U: Unsigned + Sub<B1>,
    <U as Sub<B1>>::Output: 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

fn sub(self, B1) -> <UInt<U, B0> as Sub<B1>>::Output

The method for the - operator

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

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

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

impl<T, N> ArrayLength<T> for UInt<N, B0> where
    N: ArrayLength<T>, 

type ArrayType = GenericArrayImplEven<T, <N as ArrayLength<T>>::ArrayType>

Associated type representing the array type for the number

impl<T, N> ArrayLength<T> for UInt<N, B1> where
    N: ArrayLength<T>, 

type ArrayType = GenericArrayImplOdd<T, <N as ArrayLength<T>>::ArrayType>

Associated type representing the array type for the number