typenum/
uint.rs

1//! Type-level unsigned integers.
2//!
3//!
4//! **Type operators** implemented:
5//!
6//! From `::core::ops`: `BitAnd`, `BitOr`, `BitXor`, `Shl`, `Shr`, `Add`, `Sub`,
7//!                 `Mul`, `Div`, and `Rem`.
8//! From `typenum`: `Same`, `Cmp`, and `Pow`.
9//!
10//! Rather than directly using the structs defined in this module, it is recommended that
11//! you import and use the relevant aliases from the [consts](../consts/index.html) module.
12//!
13//! # Example
14//! ```rust
15//! use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Rem, Shl, Shr, Sub};
16//! use typenum::{Unsigned, U1, U2, U3, U4};
17//!
18//! assert_eq!(<U3 as BitAnd<U2>>::Output::to_u32(), 2);
19//! assert_eq!(<U3 as BitOr<U4>>::Output::to_u32(), 7);
20//! assert_eq!(<U3 as BitXor<U2>>::Output::to_u32(), 1);
21//! assert_eq!(<U3 as Shl<U1>>::Output::to_u32(), 6);
22//! assert_eq!(<U3 as Shr<U1>>::Output::to_u32(), 1);
23//! assert_eq!(<U3 as Add<U2>>::Output::to_u32(), 5);
24//! assert_eq!(<U3 as Sub<U2>>::Output::to_u32(), 1);
25//! assert_eq!(<U3 as Mul<U2>>::Output::to_u32(), 6);
26//! assert_eq!(<U3 as Div<U2>>::Output::to_u32(), 1);
27//! assert_eq!(<U3 as Rem<U2>>::Output::to_u32(), 1);
28//! ```
29
30use crate::{
31    bit::{Bit, B0, B1},
32    consts::{U0, U1},
33    private::{
34        BitDiff, BitDiffOut, Internal, InternalMarker, PrivateAnd, PrivateAndOut, PrivateCmp,
35        PrivateCmpOut, PrivateLogarithm2, PrivatePow, PrivatePowOut, PrivateSquareRoot, PrivateSub,
36        PrivateSubOut, PrivateXor, PrivateXorOut, Trim, TrimOut,
37    },
38    Add1, Cmp, Double, Equal, Gcd, Gcf, GrEq, Greater, IsGreaterOrEqual, Len, Length, Less, Log2,
39    Logarithm2, Maximum, Minimum, NonZero, Or, Ord, Pow, Prod, Shleft, Shright, Sqrt, Square,
40    SquareRoot, Sub1, Sum, ToInt, Zero,
41};
42use core::ops::{Add, BitAnd, BitOr, BitXor, Mul, Shl, Shr, Sub};
43
44pub use crate::marker_traits::{PowerOfTwo, Unsigned};
45
46/// The terminating type for `UInt`; it always comes after the most significant
47/// bit. `UTerm` by itself represents zero, which is aliased to `U0`.
48#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
49#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))]
50pub struct UTerm;
51
52impl UTerm {
53    /// Instantiates a singleton representing this unsigned integer.
54    #[inline]
55    pub fn new() -> UTerm {
56        UTerm
57    }
58}
59
60impl Unsigned for UTerm {
61    const U8: u8 = 0;
62    const U16: u16 = 0;
63    const U32: u32 = 0;
64    const U64: u64 = 0;
65    #[cfg(feature = "i128")]
66    const U128: u128 = 0;
67    const USIZE: usize = 0;
68
69    const I8: i8 = 0;
70    const I16: i16 = 0;
71    const I32: i32 = 0;
72    const I64: i64 = 0;
73    #[cfg(feature = "i128")]
74    const I128: i128 = 0;
75    const ISIZE: isize = 0;
76
77    #[inline]
78    fn to_u8() -> u8 {
79        0
80    }
81    #[inline]
82    fn to_u16() -> u16 {
83        0
84    }
85    #[inline]
86    fn to_u32() -> u32 {
87        0
88    }
89    #[inline]
90    fn to_u64() -> u64 {
91        0
92    }
93    #[cfg(feature = "i128")]
94    #[inline]
95    fn to_u128() -> u128 {
96        0
97    }
98    #[inline]
99    fn to_usize() -> usize {
100        0
101    }
102
103    #[inline]
104    fn to_i8() -> i8 {
105        0
106    }
107    #[inline]
108    fn to_i16() -> i16 {
109        0
110    }
111    #[inline]
112    fn to_i32() -> i32 {
113        0
114    }
115    #[inline]
116    fn to_i64() -> i64 {
117        0
118    }
119    #[cfg(feature = "i128")]
120    #[inline]
121    fn to_i128() -> i128 {
122        0
123    }
124    #[inline]
125    fn to_isize() -> isize {
126        0
127    }
128}
129
130/// `UInt` is defined recursively, where `B` is the least significant bit and `U` is the rest
131/// of the number. Conceptually, `U` should be bound by the trait `Unsigned` and `B` should
132/// be bound by the trait `Bit`, but enforcing these bounds causes linear instead of
133/// logrithmic scaling in some places, so they are left off for now. They may be enforced in
134/// future.
135///
136/// In order to keep numbers unique, leading zeros are not allowed, so `UInt<UTerm, B0>` is
137/// forbidden.
138///
139/// # Example
140/// ```rust
141/// use typenum::{UInt, UTerm, B0, B1};
142///
143/// # #[allow(dead_code)]
144/// type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
145/// ```
146#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)]
147#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))]
148pub struct UInt<U, B> {
149    /// The more significant bits of `Self`.
150    pub(crate) msb: U,
151    /// The least significant bit of `Self`.
152    pub(crate) lsb: B,
153}
154
155impl<U: Unsigned, B: Bit> UInt<U, B> {
156    /// Instantiates a singleton representing this unsigned integer.
157    #[inline]
158    pub fn new() -> UInt<U, B> {
159        UInt::default()
160    }
161}
162
163impl<U: Unsigned, B: Bit> Unsigned for UInt<U, B> {
164    const U8: u8 = B::U8 | U::U8 << 1;
165    const U16: u16 = B::U8 as u16 | U::U16 << 1;
166    const U32: u32 = B::U8 as u32 | U::U32 << 1;
167    const U64: u64 = B::U8 as u64 | U::U64 << 1;
168    #[cfg(feature = "i128")]
169    const U128: u128 = B::U8 as u128 | U::U128 << 1;
170    const USIZE: usize = B::U8 as usize | U::USIZE << 1;
171
172    const I8: i8 = B::U8 as i8 | U::I8 << 1;
173    const I16: i16 = B::U8 as i16 | U::I16 << 1;
174    const I32: i32 = B::U8 as i32 | U::I32 << 1;
175    const I64: i64 = B::U8 as i64 | U::I64 << 1;
176    #[cfg(feature = "i128")]
177    const I128: i128 = B::U8 as i128 | U::I128 << 1;
178    const ISIZE: isize = B::U8 as isize | U::ISIZE << 1;
179
180    #[inline]
181    fn to_u8() -> u8 {
182        B::to_u8() | U::to_u8() << 1
183    }
184    #[inline]
185    fn to_u16() -> u16 {
186        u16::from(B::to_u8()) | U::to_u16() << 1
187    }
188    #[inline]
189    fn to_u32() -> u32 {
190        u32::from(B::to_u8()) | U::to_u32() << 1
191    }
192    #[inline]
193    fn to_u64() -> u64 {
194        u64::from(B::to_u8()) | U::to_u64() << 1
195    }
196    #[cfg(feature = "i128")]
197    #[inline]
198    fn to_u128() -> u128 {
199        u128::from(B::to_u8()) | U::to_u128() << 1
200    }
201    #[inline]
202    fn to_usize() -> usize {
203        usize::from(B::to_u8()) | U::to_usize() << 1
204    }
205
206    #[inline]
207    fn to_i8() -> i8 {
208        B::to_u8() as i8 | U::to_i8() << 1
209    }
210    #[inline]
211    fn to_i16() -> i16 {
212        i16::from(B::to_u8()) | U::to_i16() << 1
213    }
214    #[inline]
215    fn to_i32() -> i32 {
216        i32::from(B::to_u8()) | U::to_i32() << 1
217    }
218    #[inline]
219    fn to_i64() -> i64 {
220        i64::from(B::to_u8()) | U::to_i64() << 1
221    }
222    #[cfg(feature = "i128")]
223    #[inline]
224    fn to_i128() -> i128 {
225        i128::from(B::to_u8()) | U::to_i128() << 1
226    }
227    #[inline]
228    fn to_isize() -> isize {
229        B::to_u8() as isize | U::to_isize() << 1
230    }
231}
232
233impl<U: Unsigned, B: Bit> NonZero for UInt<U, B> {}
234impl Zero for UTerm {}
235
236impl PowerOfTwo for UInt<UTerm, B1> {}
237impl<U: Unsigned + PowerOfTwo> PowerOfTwo for UInt<U, B0> {}
238
239// ---------------------------------------------------------------------------------------
240// Getting length of unsigned integers, which is defined as the number of bits before `UTerm`
241
242/// Length of `UTerm` by itself is 0
243impl Len for UTerm {
244    type Output = U0;
245    #[inline]
246    fn len(&self) -> Self::Output {
247        UTerm
248    }
249}
250
251/// Length of a bit is 1
252impl<U: Unsigned, B: Bit> Len for UInt<U, B>
253where
254    U: Len,
255    Length<U>: Add<B1>,
256    Add1<Length<U>>: Unsigned,
257{
258    type Output = Add1<Length<U>>;
259    #[inline]
260    fn len(&self) -> Self::Output {
261        self.msb.len() + B1
262    }
263}
264
265// ---------------------------------------------------------------------------------------
266// Adding bits to unsigned integers
267
268/// `UTerm + B0 = UTerm`
269impl Add<B0> for UTerm {
270    type Output = UTerm;
271    #[inline]
272    fn add(self, _: B0) -> Self::Output {
273        UTerm
274    }
275}
276
277/// `U + B0 = U`
278impl<U: Unsigned, B: Bit> Add<B0> for UInt<U, B> {
279    type Output = UInt<U, B>;
280    #[inline]
281    fn add(self, _: B0) -> Self::Output {
282        UInt::new()
283    }
284}
285
286/// `UTerm + B1 = UInt<UTerm, B1>`
287impl Add<B1> for UTerm {
288    type Output = UInt<UTerm, B1>;
289    #[inline]
290    fn add(self, _: B1) -> Self::Output {
291        UInt::new()
292    }
293}
294
295/// `UInt<U, B0> + B1 = UInt<U + B1>`
296impl<U: Unsigned> Add<B1> for UInt<U, B0> {
297    type Output = UInt<U, B1>;
298    #[inline]
299    fn add(self, _: B1) -> Self::Output {
300        UInt::new()
301    }
302}
303
304/// `UInt<U, B1> + B1 = UInt<U + B1, B0>`
305impl<U: Unsigned> Add<B1> for UInt<U, B1>
306where
307    U: Add<B1>,
308    Add1<U>: Unsigned,
309{
310    type Output = UInt<Add1<U>, B0>;
311    #[inline]
312    fn add(self, _: B1) -> Self::Output {
313        UInt::new()
314    }
315}
316
317// ---------------------------------------------------------------------------------------
318// Adding unsigned integers
319
320/// `UTerm + U = U`
321impl<U: Unsigned> Add<U> for UTerm {
322    type Output = U;
323    #[inline]
324    fn add(self, rhs: U) -> Self::Output {
325        rhs
326    }
327}
328
329/// `UInt<U, B> + UTerm = UInt<U, B>`
330impl<U: Unsigned, B: Bit> Add<UTerm> for UInt<U, B> {
331    type Output = UInt<U, B>;
332    #[inline]
333    fn add(self, _: UTerm) -> Self::Output {
334        UInt::new()
335    }
336}
337
338/// `UInt<Ul, B0> + UInt<Ur, B0> = UInt<Ul + Ur, B0>`
339impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B0>
340where
341    Ul: Add<Ur>,
342{
343    type Output = UInt<Sum<Ul, Ur>, B0>;
344    #[inline]
345    fn add(self, rhs: UInt<Ur, B0>) -> Self::Output {
346        UInt {
347            msb: self.msb + rhs.msb,
348            lsb: B0,
349        }
350    }
351}
352
353/// `UInt<Ul, B0> + UInt<Ur, B1> = UInt<Ul + Ur, B1>`
354impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B0>
355where
356    Ul: Add<Ur>,
357{
358    type Output = UInt<Sum<Ul, Ur>, B1>;
359    #[inline]
360    fn add(self, rhs: UInt<Ur, B1>) -> Self::Output {
361        UInt {
362            msb: self.msb + rhs.msb,
363            lsb: B1,
364        }
365    }
366}
367
368/// `UInt<Ul, B1> + UInt<Ur, B0> = UInt<Ul + Ur, B1>`
369impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B0>> for UInt<Ul, B1>
370where
371    Ul: Add<Ur>,
372{
373    type Output = UInt<Sum<Ul, Ur>, B1>;
374    #[inline]
375    fn add(self, rhs: UInt<Ur, B0>) -> Self::Output {
376        UInt {
377            msb: self.msb + rhs.msb,
378            lsb: B1,
379        }
380    }
381}
382
383/// `UInt<Ul, B1> + UInt<Ur, B1> = UInt<(Ul + Ur) + B1, B0>`
384impl<Ul: Unsigned, Ur: Unsigned> Add<UInt<Ur, B1>> for UInt<Ul, B1>
385where
386    Ul: Add<Ur>,
387    Sum<Ul, Ur>: Add<B1>,
388{
389    type Output = UInt<Add1<Sum<Ul, Ur>>, B0>;
390    #[inline]
391    fn add(self, rhs: UInt<Ur, B1>) -> Self::Output {
392        UInt {
393            msb: self.msb + rhs.msb + B1,
394            lsb: B0,
395        }
396    }
397}
398
399// ---------------------------------------------------------------------------------------
400// Subtracting bits from unsigned integers
401
402/// `UTerm - B0 = Term`
403impl Sub<B0> for UTerm {
404    type Output = UTerm;
405    #[inline]
406    fn sub(self, _: B0) -> Self::Output {
407        UTerm
408    }
409}
410
411/// `UInt - B0 = UInt`
412impl<U: Unsigned, B: Bit> Sub<B0> for UInt<U, B> {
413    type Output = UInt<U, B>;
414    #[inline]
415    fn sub(self, _: B0) -> Self::Output {
416        UInt::new()
417    }
418}
419
420/// `UInt<U, B1> - B1 = UInt<U, B0>`
421impl<U: Unsigned, B: Bit> Sub<B1> for UInt<UInt<U, B>, B1> {
422    type Output = UInt<UInt<U, B>, B0>;
423    #[inline]
424    fn sub(self, _: B1) -> Self::Output {
425        UInt::new()
426    }
427}
428
429/// `UInt<UTerm, B1> - B1 = UTerm`
430impl Sub<B1> for UInt<UTerm, B1> {
431    type Output = UTerm;
432    #[inline]
433    fn sub(self, _: B1) -> Self::Output {
434        UTerm
435    }
436}
437
438/// `UInt<U, B0> - B1 = UInt<U - B1, B1>`
439impl<U: Unsigned> Sub<B1> for UInt<U, B0>
440where
441    U: Sub<B1>,
442    Sub1<U>: Unsigned,
443{
444    type Output = UInt<Sub1<U>, B1>;
445    #[inline]
446    fn sub(self, _: B1) -> Self::Output {
447        UInt::new()
448    }
449}
450
451// ---------------------------------------------------------------------------------------
452// Subtracting unsigned integers
453
454/// `UTerm - UTerm = UTerm`
455impl Sub<UTerm> for UTerm {
456    type Output = UTerm;
457    #[inline]
458    fn sub(self, _: UTerm) -> Self::Output {
459        UTerm
460    }
461}
462
463/// Subtracting unsigned integers. We just do our `PrivateSub` and then `Trim` the output.
464impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> Sub<Ur> for UInt<Ul, Bl>
465where
466    UInt<Ul, Bl>: PrivateSub<Ur>,
467    PrivateSubOut<UInt<Ul, Bl>, Ur>: Trim,
468{
469    type Output = TrimOut<PrivateSubOut<UInt<Ul, Bl>, Ur>>;
470    #[inline]
471    fn sub(self, rhs: Ur) -> Self::Output {
472        self.private_sub(rhs).trim()
473    }
474}
475
476/// `U - UTerm = U`
477impl<U: Unsigned> PrivateSub<UTerm> for U {
478    type Output = U;
479
480    #[inline]
481    fn private_sub(self, _: UTerm) -> Self::Output {
482        self
483    }
484}
485
486/// `UInt<Ul, B0> - UInt<Ur, B0> = UInt<Ul - Ur, B0>`
487impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B0>> for UInt<Ul, B0>
488where
489    Ul: PrivateSub<Ur>,
490{
491    type Output = UInt<PrivateSubOut<Ul, Ur>, B0>;
492
493    #[inline]
494    fn private_sub(self, rhs: UInt<Ur, B0>) -> Self::Output {
495        UInt {
496            msb: self.msb.private_sub(rhs.msb),
497            lsb: B0,
498        }
499    }
500}
501
502/// `UInt<Ul, B0> - UInt<Ur, B1> = UInt<(Ul - Ur) - B1, B1>`
503impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B1>> for UInt<Ul, B0>
504where
505    Ul: PrivateSub<Ur>,
506    PrivateSubOut<Ul, Ur>: Sub<B1>,
507{
508    type Output = UInt<Sub1<PrivateSubOut<Ul, Ur>>, B1>;
509
510    #[inline]
511    fn private_sub(self, rhs: UInt<Ur, B1>) -> Self::Output {
512        UInt {
513            msb: self.msb.private_sub(rhs.msb) - B1,
514            lsb: B1,
515        }
516    }
517}
518
519/// `UInt<Ul, B1> - UInt<Ur, B0> = UInt<Ul - Ur, B1>`
520impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B0>> for UInt<Ul, B1>
521where
522    Ul: PrivateSub<Ur>,
523{
524    type Output = UInt<PrivateSubOut<Ul, Ur>, B1>;
525
526    #[inline]
527    fn private_sub(self, rhs: UInt<Ur, B0>) -> Self::Output {
528        UInt {
529            msb: self.msb.private_sub(rhs.msb),
530            lsb: B1,
531        }
532    }
533}
534
535/// `UInt<Ul, B1> - UInt<Ur, B1> = UInt<Ul - Ur, B0>`
536impl<Ul: Unsigned, Ur: Unsigned> PrivateSub<UInt<Ur, B1>> for UInt<Ul, B1>
537where
538    Ul: PrivateSub<Ur>,
539{
540    type Output = UInt<PrivateSubOut<Ul, Ur>, B0>;
541
542    #[inline]
543    fn private_sub(self, rhs: UInt<Ur, B1>) -> Self::Output {
544        UInt {
545            msb: self.msb.private_sub(rhs.msb),
546            lsb: B0,
547        }
548    }
549}
550
551// ---------------------------------------------------------------------------------------
552// And unsigned integers
553
554/// 0 & X = 0
555impl<Ur: Unsigned> BitAnd<Ur> for UTerm {
556    type Output = UTerm;
557    #[inline]
558    fn bitand(self, _: Ur) -> Self::Output {
559        UTerm
560    }
561}
562
563/// Anding unsigned integers.
564/// We use our `PrivateAnd` operator and then `Trim` the output.
565impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitAnd<Ur> for UInt<Ul, Bl>
566where
567    UInt<Ul, Bl>: PrivateAnd<Ur>,
568    PrivateAndOut<UInt<Ul, Bl>, Ur>: Trim,
569{
570    type Output = TrimOut<PrivateAndOut<UInt<Ul, Bl>, Ur>>;
571    #[inline]
572    fn bitand(self, rhs: Ur) -> Self::Output {
573        self.private_and(rhs).trim()
574    }
575}
576
577/// `UTerm & X = UTerm`
578impl<U: Unsigned> PrivateAnd<U> for UTerm {
579    type Output = UTerm;
580
581    #[inline]
582    fn private_and(self, _: U) -> Self::Output {
583        UTerm
584    }
585}
586
587/// `X & UTerm = UTerm`
588impl<B: Bit, U: Unsigned> PrivateAnd<UTerm> for UInt<U, B> {
589    type Output = UTerm;
590
591    #[inline]
592    fn private_and(self, _: UTerm) -> Self::Output {
593        UTerm
594    }
595}
596
597/// `UInt<Ul, B0> & UInt<Ur, B0> = UInt<Ul & Ur, B0>`
598impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B0>> for UInt<Ul, B0>
599where
600    Ul: PrivateAnd<Ur>,
601{
602    type Output = UInt<PrivateAndOut<Ul, Ur>, B0>;
603
604    #[inline]
605    fn private_and(self, rhs: UInt<Ur, B0>) -> Self::Output {
606        UInt {
607            msb: self.msb.private_and(rhs.msb),
608            lsb: B0,
609        }
610    }
611}
612
613/// `UInt<Ul, B0> & UInt<Ur, B1> = UInt<Ul & Ur, B0>`
614impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B1>> for UInt<Ul, B0>
615where
616    Ul: PrivateAnd<Ur>,
617{
618    type Output = UInt<PrivateAndOut<Ul, Ur>, B0>;
619
620    #[inline]
621    fn private_and(self, rhs: UInt<Ur, B1>) -> Self::Output {
622        UInt {
623            msb: self.msb.private_and(rhs.msb),
624            lsb: B0,
625        }
626    }
627}
628
629/// `UInt<Ul, B1> & UInt<Ur, B0> = UInt<Ul & Ur, B0>`
630impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B0>> for UInt<Ul, B1>
631where
632    Ul: PrivateAnd<Ur>,
633{
634    type Output = UInt<PrivateAndOut<Ul, Ur>, B0>;
635
636    #[inline]
637    fn private_and(self, rhs: UInt<Ur, B0>) -> Self::Output {
638        UInt {
639            msb: self.msb.private_and(rhs.msb),
640            lsb: B0,
641        }
642    }
643}
644
645/// `UInt<Ul, B1> & UInt<Ur, B1> = UInt<Ul & Ur, B1>`
646impl<Ul: Unsigned, Ur: Unsigned> PrivateAnd<UInt<Ur, B1>> for UInt<Ul, B1>
647where
648    Ul: PrivateAnd<Ur>,
649{
650    type Output = UInt<PrivateAndOut<Ul, Ur>, B1>;
651
652    #[inline]
653    fn private_and(self, rhs: UInt<Ur, B1>) -> Self::Output {
654        UInt {
655            msb: self.msb.private_and(rhs.msb),
656            lsb: B1,
657        }
658    }
659}
660
661// ---------------------------------------------------------------------------------------
662// Or unsigned integers
663
664/// `UTerm | X = X`
665impl<U: Unsigned> BitOr<U> for UTerm {
666    type Output = U;
667    #[inline]
668    fn bitor(self, rhs: U) -> Self::Output {
669        rhs
670    }
671}
672
673///  `X | UTerm = X`
674impl<B: Bit, U: Unsigned> BitOr<UTerm> for UInt<U, B> {
675    type Output = Self;
676    #[inline]
677    fn bitor(self, _: UTerm) -> Self::Output {
678        UInt::new()
679    }
680}
681
682/// `UInt<Ul, B0> | UInt<Ur, B0> = UInt<Ul | Ur, B0>`
683impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B0>
684where
685    Ul: BitOr<Ur>,
686{
687    type Output = UInt<<Ul as BitOr<Ur>>::Output, B0>;
688    #[inline]
689    fn bitor(self, rhs: UInt<Ur, B0>) -> Self::Output {
690        UInt {
691            msb: self.msb.bitor(rhs.msb),
692            lsb: B0,
693        }
694    }
695}
696
697/// `UInt<Ul, B0> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`
698impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B0>
699where
700    Ul: BitOr<Ur>,
701{
702    type Output = UInt<Or<Ul, Ur>, B1>;
703    #[inline]
704    fn bitor(self, rhs: UInt<Ur, B1>) -> Self::Output {
705        UInt {
706            msb: self.msb.bitor(rhs.msb),
707            lsb: self.lsb.bitor(rhs.lsb),
708        }
709    }
710}
711
712/// `UInt<Ul, B1> | UInt<Ur, B0> = UInt<Ul | Ur, B1>`
713impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B0>> for UInt<Ul, B1>
714where
715    Ul: BitOr<Ur>,
716{
717    type Output = UInt<Or<Ul, Ur>, B1>;
718    #[inline]
719    fn bitor(self, rhs: UInt<Ur, B0>) -> Self::Output {
720        UInt {
721            msb: self.msb.bitor(rhs.msb),
722            lsb: self.lsb.bitor(rhs.lsb),
723        }
724    }
725}
726
727/// `UInt<Ul, B1> | UInt<Ur, B1> = UInt<Ul | Ur, B1>`
728impl<Ul: Unsigned, Ur: Unsigned> BitOr<UInt<Ur, B1>> for UInt<Ul, B1>
729where
730    Ul: BitOr<Ur>,
731{
732    type Output = UInt<Or<Ul, Ur>, B1>;
733    #[inline]
734    fn bitor(self, rhs: UInt<Ur, B1>) -> Self::Output {
735        UInt {
736            msb: self.msb.bitor(rhs.msb),
737            lsb: self.lsb.bitor(rhs.lsb),
738        }
739    }
740}
741
742// ---------------------------------------------------------------------------------------
743// Xor unsigned integers
744
745/// 0 ^ X = X
746impl<Ur: Unsigned> BitXor<Ur> for UTerm {
747    type Output = Ur;
748    #[inline]
749    fn bitxor(self, rhs: Ur) -> Self::Output {
750        rhs
751    }
752}
753
754/// Xoring unsigned integers.
755/// We use our `PrivateXor` operator and then `Trim` the output.
756impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned> BitXor<Ur> for UInt<Ul, Bl>
757where
758    UInt<Ul, Bl>: PrivateXor<Ur>,
759    PrivateXorOut<UInt<Ul, Bl>, Ur>: Trim,
760{
761    type Output = TrimOut<PrivateXorOut<UInt<Ul, Bl>, Ur>>;
762    #[inline]
763    fn bitxor(self, rhs: Ur) -> Self::Output {
764        self.private_xor(rhs).trim()
765    }
766}
767
768/// `UTerm ^ X = X`
769impl<U: Unsigned> PrivateXor<U> for UTerm {
770    type Output = U;
771
772    #[inline]
773    fn private_xor(self, rhs: U) -> Self::Output {
774        rhs
775    }
776}
777
778/// `X ^ UTerm = X`
779impl<B: Bit, U: Unsigned> PrivateXor<UTerm> for UInt<U, B> {
780    type Output = Self;
781
782    #[inline]
783    fn private_xor(self, _: UTerm) -> Self::Output {
784        self
785    }
786}
787
788/// `UInt<Ul, B0> ^ UInt<Ur, B0> = UInt<Ul ^ Ur, B0>`
789impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B0>> for UInt<Ul, B0>
790where
791    Ul: PrivateXor<Ur>,
792{
793    type Output = UInt<PrivateXorOut<Ul, Ur>, B0>;
794
795    #[inline]
796    fn private_xor(self, rhs: UInt<Ur, B0>) -> Self::Output {
797        UInt {
798            msb: self.msb.private_xor(rhs.msb),
799            lsb: B0,
800        }
801    }
802}
803
804/// `UInt<Ul, B0> ^ UInt<Ur, B1> = UInt<Ul ^ Ur, B1>`
805impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B1>> for UInt<Ul, B0>
806where
807    Ul: PrivateXor<Ur>,
808{
809    type Output = UInt<PrivateXorOut<Ul, Ur>, B1>;
810
811    #[inline]
812    fn private_xor(self, rhs: UInt<Ur, B1>) -> Self::Output {
813        UInt {
814            msb: self.msb.private_xor(rhs.msb),
815            lsb: B1,
816        }
817    }
818}
819
820/// `UInt<Ul, B1> ^ UInt<Ur, B0> = UInt<Ul ^ Ur, B1>`
821impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B0>> for UInt<Ul, B1>
822where
823    Ul: PrivateXor<Ur>,
824{
825    type Output = UInt<PrivateXorOut<Ul, Ur>, B1>;
826
827    #[inline]
828    fn private_xor(self, rhs: UInt<Ur, B0>) -> Self::Output {
829        UInt {
830            msb: self.msb.private_xor(rhs.msb),
831            lsb: B1,
832        }
833    }
834}
835
836/// `UInt<Ul, B1> ^ UInt<Ur, B1> = UInt<Ul ^ Ur, B0>`
837impl<Ul: Unsigned, Ur: Unsigned> PrivateXor<UInt<Ur, B1>> for UInt<Ul, B1>
838where
839    Ul: PrivateXor<Ur>,
840{
841    type Output = UInt<PrivateXorOut<Ul, Ur>, B0>;
842
843    #[inline]
844    fn private_xor(self, rhs: UInt<Ur, B1>) -> Self::Output {
845        UInt {
846            msb: self.msb.private_xor(rhs.msb),
847            lsb: B0,
848        }
849    }
850}
851
852// ---------------------------------------------------------------------------------------
853// Shl unsigned integers
854
855/// Shifting `UTerm` by a 0 bit: `UTerm << B0 = UTerm`
856impl Shl<B0> for UTerm {
857    type Output = UTerm;
858    #[inline]
859    fn shl(self, _: B0) -> Self::Output {
860        UTerm
861    }
862}
863
864/// Shifting `UTerm` by a 1 bit: `UTerm << B1 = UTerm`
865impl Shl<B1> for UTerm {
866    type Output = UTerm;
867    #[inline]
868    fn shl(self, _: B1) -> Self::Output {
869        UTerm
870    }
871}
872
873/// Shifting left any unsigned by a zero bit: `U << B0 = U`
874impl<U: Unsigned, B: Bit> Shl<B0> for UInt<U, B> {
875    type Output = UInt<U, B>;
876    #[inline]
877    fn shl(self, _: B0) -> Self::Output {
878        UInt::new()
879    }
880}
881
882/// Shifting left a `UInt` by a one bit: `UInt<U, B> << B1 = UInt<UInt<U, B>, B0>`
883impl<U: Unsigned, B: Bit> Shl<B1> for UInt<U, B> {
884    type Output = UInt<UInt<U, B>, B0>;
885    #[inline]
886    fn shl(self, _: B1) -> Self::Output {
887        UInt::new()
888    }
889}
890
891/// Shifting left `UInt` by `UTerm`: `UInt<U, B> << UTerm = UInt<U, B>`
892impl<U: Unsigned, B: Bit> Shl<UTerm> for UInt<U, B> {
893    type Output = UInt<U, B>;
894    #[inline]
895    fn shl(self, _: UTerm) -> Self::Output {
896        UInt::new()
897    }
898}
899
900/// Shifting left `UTerm` by an unsigned integer: `UTerm << U = UTerm`
901impl<U: Unsigned> Shl<U> for UTerm {
902    type Output = UTerm;
903    #[inline]
904    fn shl(self, _: U) -> Self::Output {
905        UTerm
906    }
907}
908
909/// Shifting left `UInt` by `UInt`: `X << Y` = `UInt(X, B0) << (Y - 1)`
910impl<U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit> Shl<UInt<Ur, Br>> for UInt<U, B>
911where
912    UInt<Ur, Br>: Sub<B1>,
913    UInt<UInt<U, B>, B0>: Shl<Sub1<UInt<Ur, Br>>>,
914{
915    type Output = Shleft<UInt<UInt<U, B>, B0>, Sub1<UInt<Ur, Br>>>;
916    #[inline]
917    fn shl(self, rhs: UInt<Ur, Br>) -> Self::Output {
918        (UInt { msb: self, lsb: B0 }).shl(rhs - B1)
919    }
920}
921
922// ---------------------------------------------------------------------------------------
923// Shr unsigned integers
924
925/// Shifting right a `UTerm` by an unsigned integer: `UTerm >> U = UTerm`
926impl<U: Unsigned> Shr<U> for UTerm {
927    type Output = UTerm;
928    #[inline]
929    fn shr(self, _: U) -> Self::Output {
930        UTerm
931    }
932}
933
934/// Shifting right `UInt` by `UTerm`: `UInt<U, B> >> UTerm = UInt<U, B>`
935impl<U: Unsigned, B: Bit> Shr<UTerm> for UInt<U, B> {
936    type Output = UInt<U, B>;
937    #[inline]
938    fn shr(self, _: UTerm) -> Self::Output {
939        UInt::new()
940    }
941}
942
943/// Shifting right `UTerm` by a 0 bit: `UTerm >> B0 = UTerm`
944impl Shr<B0> for UTerm {
945    type Output = UTerm;
946    #[inline]
947    fn shr(self, _: B0) -> Self::Output {
948        UTerm
949    }
950}
951
952/// Shifting right `UTerm` by a 1 bit: `UTerm >> B1 = UTerm`
953impl Shr<B1> for UTerm {
954    type Output = UTerm;
955    #[inline]
956    fn shr(self, _: B1) -> Self::Output {
957        UTerm
958    }
959}
960
961/// Shifting right any unsigned by a zero bit: `U >> B0 = U`
962impl<U: Unsigned, B: Bit> Shr<B0> for UInt<U, B> {
963    type Output = UInt<U, B>;
964    #[inline]
965    fn shr(self, _: B0) -> Self::Output {
966        UInt::new()
967    }
968}
969
970/// Shifting right a `UInt` by a 1 bit: `UInt<U, B> >> B1 = U`
971impl<U: Unsigned, B: Bit> Shr<B1> for UInt<U, B> {
972    type Output = U;
973    #[inline]
974    fn shr(self, _: B1) -> Self::Output {
975        self.msb
976    }
977}
978
979/// Shifting right `UInt` by `UInt`: `UInt(U, B) >> Y` = `U >> (Y - 1)`
980impl<U: Unsigned, B: Bit, Ur: Unsigned, Br: Bit> Shr<UInt<Ur, Br>> for UInt<U, B>
981where
982    UInt<Ur, Br>: Sub<B1>,
983    U: Shr<Sub1<UInt<Ur, Br>>>,
984{
985    type Output = Shright<U, Sub1<UInt<Ur, Br>>>;
986    #[inline]
987    fn shr(self, rhs: UInt<Ur, Br>) -> Self::Output {
988        self.msb.shr(rhs - B1)
989    }
990}
991
992// ---------------------------------------------------------------------------------------
993// Multiply unsigned integers
994
995/// `UInt * B0 = UTerm`
996impl<U: Unsigned, B: Bit> Mul<B0> for UInt<U, B> {
997    type Output = UTerm;
998    #[inline]
999    fn mul(self, _: B0) -> Self::Output {
1000        UTerm
1001    }
1002}
1003
1004/// `UTerm * B0 = UTerm`
1005impl Mul<B0> for UTerm {
1006    type Output = UTerm;
1007    #[inline]
1008    fn mul(self, _: B0) -> Self::Output {
1009        UTerm
1010    }
1011}
1012
1013/// `UTerm * B1 = UTerm`
1014impl Mul<B1> for UTerm {
1015    type Output = UTerm;
1016    #[inline]
1017    fn mul(self, _: B1) -> Self::Output {
1018        UTerm
1019    }
1020}
1021
1022/// `UInt * B1 = UInt`
1023impl<U: Unsigned, B: Bit> Mul<B1> for UInt<U, B> {
1024    type Output = UInt<U, B>;
1025    #[inline]
1026    fn mul(self, _: B1) -> Self::Output {
1027        UInt::new()
1028    }
1029}
1030
1031/// `UInt<U, B> * UTerm = UTerm`
1032impl<U: Unsigned, B: Bit> Mul<UTerm> for UInt<U, B> {
1033    type Output = UTerm;
1034    #[inline]
1035    fn mul(self, _: UTerm) -> Self::Output {
1036        UTerm
1037    }
1038}
1039
1040/// `UTerm * U = UTerm`
1041impl<U: Unsigned> Mul<U> for UTerm {
1042    type Output = UTerm;
1043    #[inline]
1044    fn mul(self, _: U) -> Self::Output {
1045        UTerm
1046    }
1047}
1048
1049/// `UInt<Ul, B0> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0>`
1050impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B0>
1051where
1052    Ul: Mul<UInt<Ur, B>>,
1053{
1054    type Output = UInt<Prod<Ul, UInt<Ur, B>>, B0>;
1055    #[inline]
1056    fn mul(self, rhs: UInt<Ur, B>) -> Self::Output {
1057        UInt {
1058            msb: self.msb * rhs,
1059            lsb: B0,
1060        }
1061    }
1062}
1063
1064/// `UInt<Ul, B1> * UInt<Ur, B> = UInt<(Ul * UInt<Ur, B>), B0> + UInt<Ur, B>`
1065impl<Ul: Unsigned, B: Bit, Ur: Unsigned> Mul<UInt<Ur, B>> for UInt<Ul, B1>
1066where
1067    Ul: Mul<UInt<Ur, B>>,
1068    UInt<Prod<Ul, UInt<Ur, B>>, B0>: Add<UInt<Ur, B>>,
1069{
1070    type Output = Sum<UInt<Prod<Ul, UInt<Ur, B>>, B0>, UInt<Ur, B>>;
1071    #[inline]
1072    fn mul(self, rhs: UInt<Ur, B>) -> Self::Output {
1073        UInt {
1074            msb: self.msb * rhs,
1075            lsb: B0,
1076        } + rhs
1077    }
1078}
1079
1080// ---------------------------------------------------------------------------------------
1081// Compare unsigned integers
1082
1083/// Zero == Zero
1084impl Cmp<UTerm> for UTerm {
1085    type Output = Equal;
1086
1087    #[inline]
1088    fn compare<IM: InternalMarker>(&self, _: &UTerm) -> Self::Output {
1089        Equal
1090    }
1091}
1092
1093/// Nonzero > Zero
1094impl<U: Unsigned, B: Bit> Cmp<UTerm> for UInt<U, B> {
1095    type Output = Greater;
1096
1097    #[inline]
1098    fn compare<IM: InternalMarker>(&self, _: &UTerm) -> Self::Output {
1099        Greater
1100    }
1101}
1102
1103/// Zero < Nonzero
1104impl<U: Unsigned, B: Bit> Cmp<UInt<U, B>> for UTerm {
1105    type Output = Less;
1106
1107    #[inline]
1108    fn compare<IM: InternalMarker>(&self, _: &UInt<U, B>) -> Self::Output {
1109        Less
1110    }
1111}
1112
1113/// `UInt<Ul, B0>` cmp with `UInt<Ur, B0>`: `SoFar` is `Equal`
1114impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B0>
1115where
1116    Ul: PrivateCmp<Ur, Equal>,
1117{
1118    type Output = PrivateCmpOut<Ul, Ur, Equal>;
1119
1120    #[inline]
1121    fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B0>) -> Self::Output {
1122        self.msb.private_cmp(&rhs.msb, Equal)
1123    }
1124}
1125
1126/// `UInt<Ul, B1>` cmp with `UInt<Ur, B1>`: `SoFar` is `Equal`
1127impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B1>
1128where
1129    Ul: PrivateCmp<Ur, Equal>,
1130{
1131    type Output = PrivateCmpOut<Ul, Ur, Equal>;
1132
1133    #[inline]
1134    fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B1>) -> Self::Output {
1135        self.msb.private_cmp(&rhs.msb, Equal)
1136    }
1137}
1138
1139/// `UInt<Ul, B0>` cmp with `UInt<Ur, B1>`: `SoFar` is `Less`
1140impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B1>> for UInt<Ul, B0>
1141where
1142    Ul: PrivateCmp<Ur, Less>,
1143{
1144    type Output = PrivateCmpOut<Ul, Ur, Less>;
1145
1146    #[inline]
1147    fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B1>) -> Self::Output {
1148        self.msb.private_cmp(&rhs.msb, Less)
1149    }
1150}
1151
1152/// `UInt<Ul, B1>` cmp with `UInt<Ur, B0>`: `SoFar` is `Greater`
1153impl<Ul: Unsigned, Ur: Unsigned> Cmp<UInt<Ur, B0>> for UInt<Ul, B1>
1154where
1155    Ul: PrivateCmp<Ur, Greater>,
1156{
1157    type Output = PrivateCmpOut<Ul, Ur, Greater>;
1158
1159    #[inline]
1160    fn compare<IM: InternalMarker>(&self, rhs: &UInt<Ur, B0>) -> Self::Output {
1161        self.msb.private_cmp(&rhs.msb, Greater)
1162    }
1163}
1164
1165/// Comparing non-terimal bits, with both having bit `B0`.
1166/// These are `Equal`, so we propagate `SoFar`.
1167impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B0>, SoFar> for UInt<Ul, B0>
1168where
1169    Ul: Unsigned,
1170    Ur: Unsigned,
1171    SoFar: Ord,
1172    Ul: PrivateCmp<Ur, SoFar>,
1173{
1174    type Output = PrivateCmpOut<Ul, Ur, SoFar>;
1175
1176    #[inline]
1177    fn private_cmp(&self, rhs: &UInt<Ur, B0>, so_far: SoFar) -> Self::Output {
1178        self.msb.private_cmp(&rhs.msb, so_far)
1179    }
1180}
1181
1182/// Comparing non-terimal bits, with both having bit `B1`.
1183/// These are `Equal`, so we propagate `SoFar`.
1184impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B1>, SoFar> for UInt<Ul, B1>
1185where
1186    Ul: Unsigned,
1187    Ur: Unsigned,
1188    SoFar: Ord,
1189    Ul: PrivateCmp<Ur, SoFar>,
1190{
1191    type Output = PrivateCmpOut<Ul, Ur, SoFar>;
1192
1193    #[inline]
1194    fn private_cmp(&self, rhs: &UInt<Ur, B1>, so_far: SoFar) -> Self::Output {
1195        self.msb.private_cmp(&rhs.msb, so_far)
1196    }
1197}
1198
1199/// Comparing non-terimal bits, with `Lhs` having bit `B0` and `Rhs` having bit `B1`.
1200/// `SoFar`, Lhs is `Less`.
1201impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B1>, SoFar> for UInt<Ul, B0>
1202where
1203    Ul: Unsigned,
1204    Ur: Unsigned,
1205    SoFar: Ord,
1206    Ul: PrivateCmp<Ur, Less>,
1207{
1208    type Output = PrivateCmpOut<Ul, Ur, Less>;
1209
1210    #[inline]
1211    fn private_cmp(&self, rhs: &UInt<Ur, B1>, _: SoFar) -> Self::Output {
1212        self.msb.private_cmp(&rhs.msb, Less)
1213    }
1214}
1215
1216/// Comparing non-terimal bits, with `Lhs` having bit `B1` and `Rhs` having bit `B0`.
1217/// `SoFar`, Lhs is `Greater`.
1218impl<Ul, Ur, SoFar> PrivateCmp<UInt<Ur, B0>, SoFar> for UInt<Ul, B1>
1219where
1220    Ul: Unsigned,
1221    Ur: Unsigned,
1222    SoFar: Ord,
1223    Ul: PrivateCmp<Ur, Greater>,
1224{
1225    type Output = PrivateCmpOut<Ul, Ur, Greater>;
1226
1227    #[inline]
1228    fn private_cmp(&self, rhs: &UInt<Ur, B0>, _: SoFar) -> Self::Output {
1229        self.msb.private_cmp(&rhs.msb, Greater)
1230    }
1231}
1232
1233/// Got to the end of just the `Lhs`. It's `Less`.
1234impl<U: Unsigned, B: Bit, SoFar: Ord> PrivateCmp<UInt<U, B>, SoFar> for UTerm {
1235    type Output = Less;
1236
1237    #[inline]
1238    fn private_cmp(&self, _: &UInt<U, B>, _: SoFar) -> Self::Output {
1239        Less
1240    }
1241}
1242
1243/// Got to the end of just the `Rhs`. `Lhs` is `Greater`.
1244impl<U: Unsigned, B: Bit, SoFar: Ord> PrivateCmp<UTerm, SoFar> for UInt<U, B> {
1245    type Output = Greater;
1246
1247    #[inline]
1248    fn private_cmp(&self, _: &UTerm, _: SoFar) -> Self::Output {
1249        Greater
1250    }
1251}
1252
1253/// Got to the end of both! Return `SoFar`
1254impl<SoFar: Ord> PrivateCmp<UTerm, SoFar> for UTerm {
1255    type Output = SoFar;
1256
1257    #[inline]
1258    fn private_cmp(&self, _: &UTerm, so_far: SoFar) -> Self::Output {
1259        so_far
1260    }
1261}
1262
1263// ---------------------------------------------------------------------------------------
1264// Getting difference in number of bits
1265
1266impl<Ul, Bl, Ur, Br> BitDiff<UInt<Ur, Br>> for UInt<Ul, Bl>
1267where
1268    Ul: Unsigned,
1269    Bl: Bit,
1270    Ur: Unsigned,
1271    Br: Bit,
1272    Ul: BitDiff<Ur>,
1273{
1274    type Output = BitDiffOut<Ul, Ur>;
1275}
1276
1277impl<Ul> BitDiff<UTerm> for Ul
1278where
1279    Ul: Unsigned + Len,
1280{
1281    type Output = Length<Ul>;
1282}
1283
1284// ---------------------------------------------------------------------------------------
1285// Shifting one number until it's the size of another
1286use crate::private::ShiftDiff;
1287impl<Ul: Unsigned, Ur: Unsigned> ShiftDiff<Ur> for Ul
1288where
1289    Ur: BitDiff<Ul>,
1290    Ul: Shl<BitDiffOut<Ur, Ul>>,
1291{
1292    type Output = Shleft<Ul, BitDiffOut<Ur, Ul>>;
1293}
1294
1295// ---------------------------------------------------------------------------------------
1296// Powers of unsigned integers
1297
1298/// X^N
1299impl<X: Unsigned, N: Unsigned> Pow<N> for X
1300where
1301    X: PrivatePow<U1, N>,
1302{
1303    type Output = PrivatePowOut<X, U1, N>;
1304    #[inline]
1305    fn powi(self, n: N) -> Self::Output {
1306        self.private_pow(U1::new(), n)
1307    }
1308}
1309
1310impl<Y: Unsigned, X: Unsigned> PrivatePow<Y, U0> for X {
1311    type Output = Y;
1312
1313    #[inline]
1314    fn private_pow(self, y: Y, _: U0) -> Self::Output {
1315        y
1316    }
1317}
1318
1319impl<Y: Unsigned, X: Unsigned> PrivatePow<Y, U1> for X
1320where
1321    X: Mul<Y>,
1322{
1323    type Output = Prod<X, Y>;
1324
1325    #[inline]
1326    fn private_pow(self, y: Y, _: U1) -> Self::Output {
1327        self * y
1328    }
1329}
1330
1331/// N is even
1332impl<Y: Unsigned, U: Unsigned, B: Bit, X: Unsigned> PrivatePow<Y, UInt<UInt<U, B>, B0>> for X
1333where
1334    X: Mul,
1335    Square<X>: PrivatePow<Y, UInt<U, B>>,
1336{
1337    type Output = PrivatePowOut<Square<X>, Y, UInt<U, B>>;
1338
1339    #[inline]
1340    fn private_pow(self, y: Y, n: UInt<UInt<U, B>, B0>) -> Self::Output {
1341        (self * self).private_pow(y, n.msb)
1342    }
1343}
1344
1345/// N is odd
1346impl<Y: Unsigned, U: Unsigned, B: Bit, X: Unsigned> PrivatePow<Y, UInt<UInt<U, B>, B1>> for X
1347where
1348    X: Mul + Mul<Y>,
1349    Square<X>: PrivatePow<Prod<X, Y>, UInt<U, B>>,
1350{
1351    type Output = PrivatePowOut<Square<X>, Prod<X, Y>, UInt<U, B>>;
1352
1353    #[inline]
1354    fn private_pow(self, y: Y, n: UInt<UInt<U, B>, B1>) -> Self::Output {
1355        (self * self).private_pow(self * y, n.msb)
1356    }
1357}
1358
1359//------------------------------------------
1360// Greatest Common Divisor
1361
1362/// The even number 2*N
1363#[allow(unused)] // Silence spurious warning on older versions of rust
1364type Even<N> = UInt<N, B0>;
1365
1366/// The odd number 2*N + 1
1367type Odd<N> = UInt<N, B1>;
1368
1369/// gcd(0, 0) = 0
1370impl Gcd<U0> for U0 {
1371    type Output = U0;
1372}
1373
1374/// gcd(x, 0) = x
1375impl<X> Gcd<U0> for X
1376where
1377    X: Unsigned + NonZero,
1378{
1379    type Output = X;
1380}
1381
1382/// gcd(0, y) = y
1383impl<Y> Gcd<Y> for U0
1384where
1385    Y: Unsigned + NonZero,
1386{
1387    type Output = Y;
1388}
1389
1390/// gcd(x, y) = 2*gcd(x/2, y/2) if both x and y even
1391impl<Xp, Yp> Gcd<Even<Yp>> for Even<Xp>
1392where
1393    Xp: Gcd<Yp>,
1394    Even<Xp>: NonZero,
1395    Even<Yp>: NonZero,
1396{
1397    type Output = UInt<Gcf<Xp, Yp>, B0>;
1398}
1399
1400/// gcd(x, y) = gcd(x, y/2) if x odd and y even
1401impl<Xp, Yp> Gcd<Even<Yp>> for Odd<Xp>
1402where
1403    Odd<Xp>: Gcd<Yp>,
1404    Even<Yp>: NonZero,
1405{
1406    type Output = Gcf<Odd<Xp>, Yp>;
1407}
1408
1409/// gcd(x, y) = gcd(x/2, y) if x even and y odd
1410impl<Xp, Yp> Gcd<Odd<Yp>> for Even<Xp>
1411where
1412    Xp: Gcd<Odd<Yp>>,
1413    Even<Xp>: NonZero,
1414{
1415    type Output = Gcf<Xp, Odd<Yp>>;
1416}
1417
1418/// gcd(x, y) = gcd([max(x, y) - min(x, y)], min(x, y)) if both x and y odd
1419///
1420/// This will immediately invoke the case for x even and y odd because the difference of two odd
1421/// numbers is an even number.
1422impl<Xp, Yp> Gcd<Odd<Yp>> for Odd<Xp>
1423where
1424    Odd<Xp>: Max<Odd<Yp>> + Min<Odd<Yp>>,
1425    Odd<Yp>: Max<Odd<Xp>> + Min<Odd<Xp>>,
1426    Maximum<Odd<Xp>, Odd<Yp>>: Sub<Minimum<Odd<Xp>, Odd<Yp>>>,
1427    Diff<Maximum<Odd<Xp>, Odd<Yp>>, Minimum<Odd<Xp>, Odd<Yp>>>: Gcd<Minimum<Odd<Xp>, Odd<Yp>>>,
1428{
1429    type Output =
1430        Gcf<Diff<Maximum<Odd<Xp>, Odd<Yp>>, Minimum<Odd<Xp>, Odd<Yp>>>, Minimum<Odd<Xp>, Odd<Yp>>>;
1431}
1432
1433#[cfg(test)]
1434mod gcd_tests {
1435    use super::*;
1436    use crate::consts::*;
1437
1438    macro_rules! gcd_test {
1439        (
1440            $( $a:ident, $b:ident => $c:ident ),* $(,)*
1441        ) => {
1442            $(
1443                assert_eq!(<Gcf<$a, $b> as Unsigned>::to_usize(), $c::to_usize());
1444                assert_eq!(<Gcf<$b, $a> as Unsigned>::to_usize(), $c::to_usize());
1445             )*
1446        }
1447    }
1448
1449    #[test]
1450    fn gcd() {
1451        gcd_test! {
1452            U0,   U0    => U0,
1453            U0,   U42   => U42,
1454            U12,  U8    => U4,
1455            U13,  U1013 => U1,  // Two primes
1456            U9,   U26   => U1,  // Not prime but coprime
1457            U143, U273  => U13,
1458            U117, U273  => U39,
1459        }
1460    }
1461}
1462
1463// -----------------------------------------
1464// GetBit
1465
1466#[allow(missing_docs)]
1467pub trait GetBit<I> {
1468    #[allow(missing_docs)]
1469    type Output;
1470
1471    #[doc(hidden)]
1472    fn get_bit<IM: InternalMarker>(&self, _: &I) -> Self::Output;
1473}
1474
1475#[allow(missing_docs)]
1476pub type GetBitOut<N, I> = <N as GetBit<I>>::Output;
1477
1478// Base case
1479impl<Un, Bn> GetBit<U0> for UInt<Un, Bn>
1480where
1481    Bn: Copy,
1482{
1483    type Output = Bn;
1484
1485    #[inline]
1486    fn get_bit<IM: InternalMarker>(&self, _: &U0) -> Self::Output {
1487        self.lsb
1488    }
1489}
1490
1491// Recursion case
1492impl<Un, Bn, Ui, Bi> GetBit<UInt<Ui, Bi>> for UInt<Un, Bn>
1493where
1494    UInt<Ui, Bi>: Copy + Sub<B1>,
1495    Un: GetBit<Sub1<UInt<Ui, Bi>>>,
1496{
1497    type Output = GetBitOut<Un, Sub1<UInt<Ui, Bi>>>;
1498
1499    #[inline]
1500    fn get_bit<IM: InternalMarker>(&self, i: &UInt<Ui, Bi>) -> Self::Output {
1501        self.msb.get_bit::<Internal>(&(*i - B1))
1502    }
1503}
1504
1505// Ran out of bits
1506impl<I> GetBit<I> for UTerm {
1507    type Output = B0;
1508
1509    #[inline]
1510    fn get_bit<IM: InternalMarker>(&self, _: &I) -> Self::Output {
1511        B0
1512    }
1513}
1514
1515#[test]
1516fn test_get_bit() {
1517    use crate::consts::*;
1518    use crate::Same;
1519    type T1 = <GetBitOut<U2, U0> as Same<B0>>::Output;
1520    type T2 = <GetBitOut<U2, U1> as Same<B1>>::Output;
1521    type T3 = <GetBitOut<U2, U2> as Same<B0>>::Output;
1522
1523    <T1 as Bit>::to_bool();
1524    <T2 as Bit>::to_bool();
1525    <T3 as Bit>::to_bool();
1526}
1527
1528// -----------------------------------------
1529// SetBit
1530
1531/// A **type operator** that, when implemented for unsigned integer `N`, sets the bit at position
1532/// `I` to `B`.
1533pub trait SetBit<I, B> {
1534    #[allow(missing_docs)]
1535    type Output;
1536
1537    #[doc(hidden)]
1538    fn set_bit<IM: InternalMarker>(self, _: I, _: B) -> Self::Output;
1539}
1540/// Alias for the result of calling `SetBit`: `SetBitOut<N, I, B> = <N as SetBit<I, B>>::Output`.
1541pub type SetBitOut<N, I, B> = <N as SetBit<I, B>>::Output;
1542
1543use crate::private::{PrivateSetBit, PrivateSetBitOut};
1544
1545// Call private one then trim it
1546impl<N, I, B> SetBit<I, B> for N
1547where
1548    N: PrivateSetBit<I, B>,
1549    PrivateSetBitOut<N, I, B>: Trim,
1550{
1551    type Output = TrimOut<PrivateSetBitOut<N, I, B>>;
1552
1553    #[inline]
1554    fn set_bit<IM: InternalMarker>(self, i: I, b: B) -> Self::Output {
1555        self.private_set_bit(i, b).trim()
1556    }
1557}
1558
1559// Base case
1560impl<Un, Bn, B> PrivateSetBit<U0, B> for UInt<Un, Bn> {
1561    type Output = UInt<Un, B>;
1562
1563    #[inline]
1564    fn private_set_bit(self, _: U0, b: B) -> Self::Output {
1565        UInt {
1566            msb: self.msb,
1567            lsb: b,
1568        }
1569    }
1570}
1571
1572// Recursion case
1573impl<Un, Bn, Ui, Bi, B> PrivateSetBit<UInt<Ui, Bi>, B> for UInt<Un, Bn>
1574where
1575    UInt<Ui, Bi>: Sub<B1>,
1576    Un: PrivateSetBit<Sub1<UInt<Ui, Bi>>, B>,
1577{
1578    type Output = UInt<PrivateSetBitOut<Un, Sub1<UInt<Ui, Bi>>, B>, Bn>;
1579
1580    #[inline]
1581    fn private_set_bit(self, i: UInt<Ui, Bi>, b: B) -> Self::Output {
1582        UInt {
1583            msb: self.msb.private_set_bit(i - B1, b),
1584            lsb: self.lsb,
1585        }
1586    }
1587}
1588
1589// Ran out of bits, setting B0
1590impl<I> PrivateSetBit<I, B0> for UTerm {
1591    type Output = UTerm;
1592
1593    #[inline]
1594    fn private_set_bit(self, _: I, _: B0) -> Self::Output {
1595        UTerm
1596    }
1597}
1598
1599// Ran out of bits, setting B1
1600impl<I> PrivateSetBit<I, B1> for UTerm
1601where
1602    U1: Shl<I>,
1603{
1604    type Output = Shleft<U1, I>;
1605
1606    #[inline]
1607    fn private_set_bit(self, i: I, _: B1) -> Self::Output {
1608        <U1 as Shl<I>>::shl(U1::new(), i)
1609    }
1610}
1611
1612#[test]
1613fn test_set_bit() {
1614    use crate::consts::*;
1615    use crate::Same;
1616    type T1 = <SetBitOut<U2, U0, B0> as Same<U2>>::Output;
1617    type T2 = <SetBitOut<U2, U0, B1> as Same<U3>>::Output;
1618    type T3 = <SetBitOut<U2, U1, B0> as Same<U0>>::Output;
1619    type T4 = <SetBitOut<U2, U1, B1> as Same<U2>>::Output;
1620    type T5 = <SetBitOut<U2, U2, B0> as Same<U2>>::Output;
1621    type T6 = <SetBitOut<U2, U2, B1> as Same<U6>>::Output;
1622    type T7 = <SetBitOut<U2, U3, B0> as Same<U2>>::Output;
1623    type T8 = <SetBitOut<U2, U3, B1> as Same<U10>>::Output;
1624    type T9 = <SetBitOut<U2, U4, B0> as Same<U2>>::Output;
1625    type T10 = <SetBitOut<U2, U4, B1> as Same<U18>>::Output;
1626
1627    type T11 = <SetBitOut<U3, U0, B0> as Same<U2>>::Output;
1628
1629    <T1 as Unsigned>::to_u32();
1630    <T2 as Unsigned>::to_u32();
1631    <T3 as Unsigned>::to_u32();
1632    <T4 as Unsigned>::to_u32();
1633    <T5 as Unsigned>::to_u32();
1634    <T6 as Unsigned>::to_u32();
1635    <T7 as Unsigned>::to_u32();
1636    <T8 as Unsigned>::to_u32();
1637    <T9 as Unsigned>::to_u32();
1638    <T10 as Unsigned>::to_u32();
1639    <T11 as Unsigned>::to_u32();
1640}
1641
1642// -----------------------------------------
1643
1644// Division algorithm:
1645// We have N / D:
1646// let Q = 0, R = 0
1647// NBits = len(N)
1648// for I in NBits-1..0:
1649//   R <<=1
1650//   R[0] = N[i]
1651//   let C = R.cmp(D)
1652//   if C == Equal or Greater:
1653//     R -= D
1654//     Q[i] = 1
1655
1656#[cfg(tests)]
1657mod tests {
1658    macro_rules! test_div {
1659        ($a:ident / $b:ident = $c:ident) => {{
1660            type R = Quot<$a, $b>;
1661            assert_eq!(<R as Unsigned>::to_usize(), $c::to_usize());
1662        }};
1663    }
1664    #[test]
1665    fn test_div() {
1666        use crate::consts::*;
1667        use crate::{Quot, Same};
1668
1669        test_div!(U0 / U1 = U0);
1670        test_div!(U1 / U1 = U1);
1671        test_div!(U2 / U1 = U2);
1672        test_div!(U3 / U1 = U3);
1673        test_div!(U4 / U1 = U4);
1674
1675        test_div!(U0 / U2 = U0);
1676        test_div!(U1 / U2 = U0);
1677        test_div!(U2 / U2 = U1);
1678        test_div!(U3 / U2 = U1);
1679        test_div!(U4 / U2 = U2);
1680        test_div!(U6 / U2 = U3);
1681        test_div!(U7 / U2 = U3);
1682
1683        type T = <SetBitOut<U0, U1, B1> as Same<U2>>::Output;
1684        <T as Unsigned>::to_u32();
1685    }
1686}
1687// -----------------------------------------
1688// Div
1689use core::ops::Div;
1690
1691// 0 // N
1692impl<Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UTerm {
1693    type Output = UTerm;
1694    #[inline]
1695    fn div(self, _: UInt<Ur, Br>) -> Self::Output {
1696        UTerm
1697    }
1698}
1699
1700// M // N
1701impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Div<UInt<Ur, Br>> for UInt<Ul, Bl>
1702where
1703    UInt<Ul, Bl>: Len,
1704    Length<UInt<Ul, Bl>>: Sub<B1>,
1705    (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>,
1706{
1707    type Output = PrivateDivQuot<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>;
1708    #[inline]
1709    #[cfg_attr(feature = "cargo-clippy", allow(clippy::suspicious_arithmetic_impl))]
1710    fn div(self, rhs: UInt<Ur, Br>) -> Self::Output {
1711        ().private_div_quotient(self, rhs, U0::new(), U0::new(), self.len() - B1)
1712    }
1713}
1714
1715// -----------------------------------------
1716// Rem
1717use core::ops::Rem;
1718
1719// 0 % N
1720impl<Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UTerm {
1721    type Output = UTerm;
1722    #[inline]
1723    fn rem(self, _: UInt<Ur, Br>) -> Self::Output {
1724        UTerm
1725    }
1726}
1727
1728// M % N
1729impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> Rem<UInt<Ur, Br>> for UInt<Ul, Bl>
1730where
1731    UInt<Ul, Bl>: Len,
1732    Length<UInt<Ul, Bl>>: Sub<B1>,
1733    (): PrivateDiv<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>,
1734{
1735    type Output = PrivateDivRem<UInt<Ul, Bl>, UInt<Ur, Br>, U0, U0, Sub1<Length<UInt<Ul, Bl>>>>;
1736    #[inline]
1737    fn rem(self, rhs: UInt<Ur, Br>) -> Self::Output {
1738        ().private_div_remainder(self, rhs, UTerm, UTerm, self.len() - B1)
1739    }
1740}
1741
1742// -----------------------------------------
1743// PrivateDiv
1744use crate::private::{PrivateDiv, PrivateDivQuot, PrivateDivRem};
1745
1746use crate::Compare;
1747// R == 0: We set R = UInt<UTerm, N[i]>, then call out to PrivateDivIf for the if statement
1748impl<N, D, Q, I> PrivateDiv<N, D, Q, U0, I> for ()
1749where
1750    N: GetBit<I>,
1751    UInt<UTerm, GetBitOut<N, I>>: Trim,
1752    TrimOut<UInt<UTerm, GetBitOut<N, I>>>: Cmp<D>,
1753    (): PrivateDivIf<
1754        N,
1755        D,
1756        Q,
1757        TrimOut<UInt<UTerm, GetBitOut<N, I>>>,
1758        I,
1759        Compare<TrimOut<UInt<UTerm, GetBitOut<N, I>>>, D>,
1760    >,
1761{
1762    type Quotient = PrivateDivIfQuot<
1763        N,
1764        D,
1765        Q,
1766        TrimOut<UInt<UTerm, GetBitOut<N, I>>>,
1767        I,
1768        Compare<TrimOut<UInt<UTerm, GetBitOut<N, I>>>, D>,
1769    >;
1770    type Remainder = PrivateDivIfRem<
1771        N,
1772        D,
1773        Q,
1774        TrimOut<UInt<UTerm, GetBitOut<N, I>>>,
1775        I,
1776        Compare<TrimOut<UInt<UTerm, GetBitOut<N, I>>>, D>,
1777    >;
1778
1779    #[inline]
1780    fn private_div_quotient(self, n: N, d: D, q: Q, _: U0, i: I) -> Self::Quotient
1781where {
1782        let r = (UInt {
1783            msb: UTerm,
1784            lsb: n.get_bit::<Internal>(&i),
1785        })
1786        .trim();
1787        let r_cmp_d = r.compare::<Internal>(&d);
1788        ().private_div_if_quotient(n, d, q, r, i, r_cmp_d)
1789    }
1790
1791    #[inline]
1792    fn private_div_remainder(self, n: N, d: D, q: Q, _: U0, i: I) -> Self::Remainder {
1793        let r = (UInt {
1794            msb: UTerm,
1795            lsb: n.get_bit::<Internal>(&i),
1796        })
1797        .trim();
1798        let r_cmp_d = r.compare::<Internal>(&d);
1799        ().private_div_if_remainder(n, d, q, r, i, r_cmp_d)
1800    }
1801}
1802
1803// R > 0: We perform R <<= 1 and R[0] = N[i], then call out to PrivateDivIf for the if statement
1804impl<N, D, Q, Ur, Br, I> PrivateDiv<N, D, Q, UInt<Ur, Br>, I> for ()
1805where
1806    N: GetBit<I>,
1807    UInt<UInt<Ur, Br>, GetBitOut<N, I>>: Cmp<D>,
1808    (): PrivateDivIf<
1809        N,
1810        D,
1811        Q,
1812        UInt<UInt<Ur, Br>, GetBitOut<N, I>>,
1813        I,
1814        Compare<UInt<UInt<Ur, Br>, GetBitOut<N, I>>, D>,
1815    >,
1816{
1817    type Quotient = PrivateDivIfQuot<
1818        N,
1819        D,
1820        Q,
1821        UInt<UInt<Ur, Br>, GetBitOut<N, I>>,
1822        I,
1823        Compare<UInt<UInt<Ur, Br>, GetBitOut<N, I>>, D>,
1824    >;
1825    type Remainder = PrivateDivIfRem<
1826        N,
1827        D,
1828        Q,
1829        UInt<UInt<Ur, Br>, GetBitOut<N, I>>,
1830        I,
1831        Compare<UInt<UInt<Ur, Br>, GetBitOut<N, I>>, D>,
1832    >;
1833
1834    #[inline]
1835    fn private_div_quotient(self, n: N, d: D, q: Q, r: UInt<Ur, Br>, i: I) -> Self::Quotient {
1836        let r = UInt {
1837            msb: r,
1838            lsb: n.get_bit::<Internal>(&i),
1839        };
1840        let r_cmp_d = r.compare::<Internal>(&d);
1841        ().private_div_if_quotient(n, d, q, r, i, r_cmp_d)
1842    }
1843
1844    #[inline]
1845    fn private_div_remainder(self, n: N, d: D, q: Q, r: UInt<Ur, Br>, i: I) -> Self::Remainder {
1846        let r = UInt {
1847            msb: r,
1848            lsb: n.get_bit::<Internal>(&i),
1849        };
1850        let r_cmp_d = r.compare::<Internal>(&d);
1851        ().private_div_if_remainder(n, d, q, r, i, r_cmp_d)
1852    }
1853}
1854
1855// -----------------------------------------
1856// PrivateDivIf
1857
1858use crate::private::{PrivateDivIf, PrivateDivIfQuot, PrivateDivIfRem};
1859
1860// R < D, I > 0, we do nothing and recurse
1861impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Less> for ()
1862where
1863    UInt<Ui, Bi>: Sub<B1>,
1864    (): PrivateDiv<N, D, Q, R, Sub1<UInt<Ui, Bi>>>,
1865{
1866    type Quotient = PrivateDivQuot<N, D, Q, R, Sub1<UInt<Ui, Bi>>>;
1867    type Remainder = PrivateDivRem<N, D, Q, R, Sub1<UInt<Ui, Bi>>>;
1868
1869    #[inline]
1870    fn private_div_if_quotient(
1871        self,
1872        n: N,
1873        d: D,
1874        q: Q,
1875        r: R,
1876        i: UInt<Ui, Bi>,
1877        _: Less,
1878    ) -> Self::Quotient
1879where {
1880        ().private_div_quotient(n, d, q, r, i - B1)
1881    }
1882
1883    #[inline]
1884    fn private_div_if_remainder(
1885        self,
1886        n: N,
1887        d: D,
1888        q: Q,
1889        r: R,
1890        i: UInt<Ui, Bi>,
1891        _: Less,
1892    ) -> Self::Remainder
1893where {
1894        ().private_div_remainder(n, d, q, r, i - B1)
1895    }
1896}
1897
1898// R == D, I > 0, we set R = 0, Q[I] = 1 and recurse
1899impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Equal> for ()
1900where
1901    UInt<Ui, Bi>: Copy + Sub<B1>,
1902    Q: SetBit<UInt<Ui, Bi>, B1>,
1903    (): PrivateDiv<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, U0, Sub1<UInt<Ui, Bi>>>,
1904{
1905    type Quotient = PrivateDivQuot<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, U0, Sub1<UInt<Ui, Bi>>>;
1906    type Remainder = PrivateDivRem<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, U0, Sub1<UInt<Ui, Bi>>>;
1907
1908    #[inline]
1909    fn private_div_if_quotient(
1910        self,
1911        n: N,
1912        d: D,
1913        q: Q,
1914        _: R,
1915        i: UInt<Ui, Bi>,
1916        _: Equal,
1917    ) -> Self::Quotient
1918where {
1919        ().private_div_quotient(n, d, q.set_bit::<Internal>(i, B1), U0::new(), i - B1)
1920    }
1921
1922    #[inline]
1923    fn private_div_if_remainder(
1924        self,
1925        n: N,
1926        d: D,
1927        q: Q,
1928        _: R,
1929        i: UInt<Ui, Bi>,
1930        _: Equal,
1931    ) -> Self::Remainder
1932where {
1933        ().private_div_remainder(n, d, q.set_bit::<Internal>(i, B1), U0::new(), i - B1)
1934    }
1935}
1936
1937use crate::Diff;
1938// R > D, I > 0, we set R -= D, Q[I] = 1 and recurse
1939impl<N, D, Q, R, Ui, Bi> PrivateDivIf<N, D, Q, R, UInt<Ui, Bi>, Greater> for ()
1940where
1941    D: Copy,
1942    UInt<Ui, Bi>: Copy + Sub<B1>,
1943    R: Sub<D>,
1944    Q: SetBit<UInt<Ui, Bi>, B1>,
1945    (): PrivateDiv<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, Diff<R, D>, Sub1<UInt<Ui, Bi>>>,
1946{
1947    type Quotient =
1948        PrivateDivQuot<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, Diff<R, D>, Sub1<UInt<Ui, Bi>>>;
1949    type Remainder =
1950        PrivateDivRem<N, D, SetBitOut<Q, UInt<Ui, Bi>, B1>, Diff<R, D>, Sub1<UInt<Ui, Bi>>>;
1951
1952    #[inline]
1953    fn private_div_if_quotient(
1954        self,
1955        n: N,
1956        d: D,
1957        q: Q,
1958        r: R,
1959        i: UInt<Ui, Bi>,
1960        _: Greater,
1961    ) -> Self::Quotient
1962where {
1963        ().private_div_quotient(n, d, q.set_bit::<Internal>(i, B1), r - d, i - B1)
1964    }
1965
1966    #[inline]
1967    fn private_div_if_remainder(
1968        self,
1969        n: N,
1970        d: D,
1971        q: Q,
1972        r: R,
1973        i: UInt<Ui, Bi>,
1974        _: Greater,
1975    ) -> Self::Remainder
1976where {
1977        ().private_div_remainder(n, d, q.set_bit::<Internal>(i, B1), r - d, i - B1)
1978    }
1979}
1980
1981// R < D, I == 0: we do nothing, and return
1982impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, U0, Less> for () {
1983    type Quotient = Q;
1984    type Remainder = R;
1985
1986    #[inline]
1987    fn private_div_if_quotient(self, _: N, _: D, q: Q, _: R, _: U0, _: Less) -> Self::Quotient {
1988        q
1989    }
1990
1991    #[inline]
1992    fn private_div_if_remainder(self, _: N, _: D, _: Q, r: R, _: U0, _: Less) -> Self::Remainder {
1993        r
1994    }
1995}
1996
1997// R == D, I == 0: we set R = 0, Q[I] = 1, and return
1998impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, U0, Equal> for ()
1999where
2000    Q: SetBit<U0, B1>,
2001{
2002    type Quotient = SetBitOut<Q, U0, B1>;
2003    type Remainder = U0;
2004
2005    #[inline]
2006    fn private_div_if_quotient(self, _: N, _: D, q: Q, _: R, i: U0, _: Equal) -> Self::Quotient {
2007        q.set_bit::<Internal>(i, B1)
2008    }
2009
2010    #[inline]
2011    fn private_div_if_remainder(self, _: N, _: D, _: Q, _: R, i: U0, _: Equal) -> Self::Remainder {
2012        i
2013    }
2014}
2015
2016// R > D, I == 0: We set R -= D, Q[I] = 1, and return
2017impl<N, D, Q, R> PrivateDivIf<N, D, Q, R, U0, Greater> for ()
2018where
2019    R: Sub<D>,
2020    Q: SetBit<U0, B1>,
2021{
2022    type Quotient = SetBitOut<Q, U0, B1>;
2023    type Remainder = Diff<R, D>;
2024
2025    #[inline]
2026    fn private_div_if_quotient(self, _: N, _: D, q: Q, _: R, i: U0, _: Greater) -> Self::Quotient {
2027        q.set_bit::<Internal>(i, B1)
2028    }
2029
2030    #[inline]
2031    fn private_div_if_remainder(
2032        self,
2033        _: N,
2034        d: D,
2035        _: Q,
2036        r: R,
2037        _: U0,
2038        _: Greater,
2039    ) -> Self::Remainder {
2040        r - d
2041    }
2042}
2043
2044// -----------------------------------------
2045// PartialDiv
2046use crate::{PartialDiv, Quot};
2047impl<Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UTerm {
2048    type Output = UTerm;
2049    #[inline]
2050    fn partial_div(self, _: UInt<Ur, Br>) -> Self::Output {
2051        UTerm
2052    }
2053}
2054
2055// M / N
2056impl<Ul: Unsigned, Bl: Bit, Ur: Unsigned, Br: Bit> PartialDiv<UInt<Ur, Br>> for UInt<Ul, Bl>
2057where
2058    UInt<Ul, Bl>: Div<UInt<Ur, Br>> + Rem<UInt<Ur, Br>, Output = U0>,
2059{
2060    type Output = Quot<UInt<Ul, Bl>, UInt<Ur, Br>>;
2061    #[inline]
2062    fn partial_div(self, rhs: UInt<Ur, Br>) -> Self::Output {
2063        self / rhs
2064    }
2065}
2066
2067// -----------------------------------------
2068// PrivateMin
2069use crate::private::{PrivateMin, PrivateMinOut};
2070
2071impl<U, B, Ur> PrivateMin<Ur, Equal> for UInt<U, B>
2072where
2073    Ur: Unsigned,
2074    U: Unsigned,
2075    B: Bit,
2076{
2077    type Output = UInt<U, B>;
2078    #[inline]
2079    fn private_min(self, _: Ur) -> Self::Output {
2080        self
2081    }
2082}
2083
2084impl<U, B, Ur> PrivateMin<Ur, Less> for UInt<U, B>
2085where
2086    Ur: Unsigned,
2087    U: Unsigned,
2088    B: Bit,
2089{
2090    type Output = UInt<U, B>;
2091    #[inline]
2092    fn private_min(self, _: Ur) -> Self::Output {
2093        self
2094    }
2095}
2096
2097impl<U, B, Ur> PrivateMin<Ur, Greater> for UInt<U, B>
2098where
2099    Ur: Unsigned,
2100    U: Unsigned,
2101    B: Bit,
2102{
2103    type Output = Ur;
2104    #[inline]
2105    fn private_min(self, rhs: Ur) -> Self::Output {
2106        rhs
2107    }
2108}
2109
2110// -----------------------------------------
2111// Min
2112use crate::Min;
2113
2114impl<U> Min<U> for UTerm
2115where
2116    U: Unsigned,
2117{
2118    type Output = UTerm;
2119    #[inline]
2120    fn min(self, _: U) -> Self::Output {
2121        self
2122    }
2123}
2124
2125impl<U, B, Ur> Min<Ur> for UInt<U, B>
2126where
2127    U: Unsigned,
2128    B: Bit,
2129    Ur: Unsigned,
2130    UInt<U, B>: Cmp<Ur> + PrivateMin<Ur, Compare<UInt<U, B>, Ur>>,
2131{
2132    type Output = PrivateMinOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>;
2133    #[inline]
2134    fn min(self, rhs: Ur) -> Self::Output {
2135        self.private_min(rhs)
2136    }
2137}
2138
2139// -----------------------------------------
2140// PrivateMax
2141use crate::private::{PrivateMax, PrivateMaxOut};
2142
2143impl<U, B, Ur> PrivateMax<Ur, Equal> for UInt<U, B>
2144where
2145    Ur: Unsigned,
2146    U: Unsigned,
2147    B: Bit,
2148{
2149    type Output = UInt<U, B>;
2150    #[inline]
2151    fn private_max(self, _: Ur) -> Self::Output {
2152        self
2153    }
2154}
2155
2156impl<U, B, Ur> PrivateMax<Ur, Less> for UInt<U, B>
2157where
2158    Ur: Unsigned,
2159    U: Unsigned,
2160    B: Bit,
2161{
2162    type Output = Ur;
2163    #[inline]
2164    fn private_max(self, rhs: Ur) -> Self::Output {
2165        rhs
2166    }
2167}
2168
2169impl<U, B, Ur> PrivateMax<Ur, Greater> for UInt<U, B>
2170where
2171    Ur: Unsigned,
2172    U: Unsigned,
2173    B: Bit,
2174{
2175    type Output = UInt<U, B>;
2176    #[inline]
2177    fn private_max(self, _: Ur) -> Self::Output {
2178        self
2179    }
2180}
2181
2182// -----------------------------------------
2183// Max
2184use crate::Max;
2185
2186impl<U> Max<U> for UTerm
2187where
2188    U: Unsigned,
2189{
2190    type Output = U;
2191    #[inline]
2192    fn max(self, rhs: U) -> Self::Output {
2193        rhs
2194    }
2195}
2196
2197impl<U, B, Ur> Max<Ur> for UInt<U, B>
2198where
2199    U: Unsigned,
2200    B: Bit,
2201    Ur: Unsigned,
2202    UInt<U, B>: Cmp<Ur> + PrivateMax<Ur, Compare<UInt<U, B>, Ur>>,
2203{
2204    type Output = PrivateMaxOut<UInt<U, B>, Ur, Compare<UInt<U, B>, Ur>>;
2205    #[inline]
2206    fn max(self, rhs: Ur) -> Self::Output {
2207        self.private_max(rhs)
2208    }
2209}
2210
2211// -----------------------------------------
2212// SquareRoot
2213
2214impl<N> SquareRoot for N
2215where
2216    N: PrivateSquareRoot,
2217{
2218    type Output = <Self as PrivateSquareRoot>::Output;
2219}
2220
2221// sqrt(0) = 0.
2222impl PrivateSquareRoot for UTerm {
2223    type Output = UTerm;
2224}
2225
2226// sqrt(1) = 1.
2227impl PrivateSquareRoot for UInt<UTerm, B1> {
2228    type Output = UInt<UTerm, B1>;
2229}
2230
2231// General case of sqrt(Self) where Self >= 2. If a and b are
2232// bit-valued and Self = 4*u + 2*a + b, then the integer-valued
2233// (fractional part truncated) square root of Self is either 2*sqrt(u)
2234// or 2*sqrt(u)+1. Guess and check by comparing (2*sqrt(u)+1)^2
2235// against Self. Since the `typenum` result of that comparison is a
2236// bit, directly add that bit to 2*sqrt(u).
2237//
2238// Use `Sum<Double<Sqrt<U>>, GrEq<...>>` instead of `UInt<Sqrt<U>,
2239// GrEq<...>>` because `Sqrt<U>` can turn out to be `UTerm` and
2240// `GrEq<...>` can turn out to be `B0`, which would not be a valid
2241// UInt as leading zeros are disallowed.
2242impl<U, Ba, Bb> PrivateSquareRoot for UInt<UInt<U, Ba>, Bb>
2243where
2244    U: Unsigned,
2245    Ba: Bit,
2246    Bb: Bit,
2247    U: SquareRoot,
2248    Sqrt<U>: Shl<B1>,
2249    Double<Sqrt<U>>: Add<B1>,
2250    Add1<Double<Sqrt<U>>>: Mul,
2251    Self: IsGreaterOrEqual<Square<Add1<Double<Sqrt<U>>>>>,
2252    Double<Sqrt<U>>: Add<GrEq<Self, Square<Add1<Double<Sqrt<U>>>>>>,
2253{
2254    type Output = Sum<Double<Sqrt<U>>, GrEq<Self, Square<Add1<Double<Sqrt<U>>>>>>;
2255}
2256
2257#[test]
2258fn sqrt_test() {
2259    use crate::consts::*;
2260
2261    assert_eq!(0, <Sqrt<U0>>::to_u32());
2262
2263    assert_eq!(1, <Sqrt<U1>>::to_u32());
2264    assert_eq!(1, <Sqrt<U2>>::to_u32());
2265    assert_eq!(1, <Sqrt<U3>>::to_u32());
2266
2267    assert_eq!(2, <Sqrt<U4>>::to_u32());
2268    assert_eq!(2, <Sqrt<U5>>::to_u32());
2269    assert_eq!(2, <Sqrt<U6>>::to_u32());
2270    assert_eq!(2, <Sqrt<U7>>::to_u32());
2271    assert_eq!(2, <Sqrt<U8>>::to_u32());
2272
2273    assert_eq!(3, <Sqrt<U9>>::to_u32());
2274    assert_eq!(3, <Sqrt<U10>>::to_u32());
2275    assert_eq!(3, <Sqrt<U11>>::to_u32());
2276    assert_eq!(3, <Sqrt<U12>>::to_u32());
2277    assert_eq!(3, <Sqrt<U13>>::to_u32());
2278    assert_eq!(3, <Sqrt<U14>>::to_u32());
2279    assert_eq!(3, <Sqrt<U15>>::to_u32());
2280
2281    assert_eq!(4, <Sqrt<U16>>::to_u32());
2282    assert_eq!(4, <Sqrt<U17>>::to_u32());
2283    assert_eq!(4, <Sqrt<U18>>::to_u32());
2284    assert_eq!(4, <Sqrt<U19>>::to_u32());
2285    assert_eq!(4, <Sqrt<U20>>::to_u32());
2286    assert_eq!(4, <Sqrt<U21>>::to_u32());
2287    assert_eq!(4, <Sqrt<U22>>::to_u32());
2288    assert_eq!(4, <Sqrt<U23>>::to_u32());
2289    assert_eq!(4, <Sqrt<U24>>::to_u32());
2290
2291    assert_eq!(5, <Sqrt<U25>>::to_u32());
2292    assert_eq!(5, <Sqrt<U26>>::to_u32());
2293    // ...
2294}
2295
2296// -----------------------------------------
2297// Logarithm2
2298
2299impl<N> Logarithm2 for N
2300where
2301    N: PrivateLogarithm2,
2302{
2303    type Output = <Self as PrivateLogarithm2>::Output;
2304}
2305
2306// log2(1) = 0.
2307impl PrivateLogarithm2 for UInt<UTerm, B1> {
2308    type Output = U0;
2309}
2310
2311// General case of log2(Self) where Self >= 2.
2312impl<U, B> PrivateLogarithm2 for UInt<U, B>
2313where
2314    U: Unsigned + Logarithm2,
2315    B: Bit,
2316    Log2<U>: Add<B1>,
2317{
2318    type Output = Add1<Log2<U>>;
2319}
2320
2321// -----------------------------------------
2322// ToInt
2323
2324impl ToInt<i8> for UTerm {
2325    #[inline]
2326    fn to_int() -> i8 {
2327        Self::I8
2328    }
2329    const INT: i8 = Self::I8;
2330}
2331
2332impl ToInt<i16> for UTerm {
2333    #[inline]
2334    fn to_int() -> i16 {
2335        Self::I16
2336    }
2337    const INT: i16 = Self::I16;
2338}
2339
2340impl ToInt<i32> for UTerm {
2341    #[inline]
2342    fn to_int() -> i32 {
2343        Self::I32
2344    }
2345    const INT: i32 = Self::I32;
2346}
2347
2348impl ToInt<i64> for UTerm {
2349    #[inline]
2350    fn to_int() -> i64 {
2351        Self::I64
2352    }
2353    const INT: i64 = Self::I64;
2354}
2355
2356impl ToInt<u8> for UTerm {
2357    #[inline]
2358    fn to_int() -> u8 {
2359        Self::U8
2360    }
2361    const INT: u8 = Self::U8;
2362}
2363
2364impl ToInt<u16> for UTerm {
2365    #[inline]
2366    fn to_int() -> u16 {
2367        Self::U16
2368    }
2369    const INT: u16 = Self::U16;
2370}
2371
2372impl ToInt<u32> for UTerm {
2373    #[inline]
2374    fn to_int() -> u32 {
2375        Self::U32
2376    }
2377    const INT: u32 = Self::U32;
2378}
2379
2380impl ToInt<u64> for UTerm {
2381    #[inline]
2382    fn to_int() -> u64 {
2383        Self::U64
2384    }
2385    const INT: u64 = Self::U64;
2386}
2387
2388impl ToInt<usize> for UTerm {
2389    #[inline]
2390    fn to_int() -> usize {
2391        Self::USIZE
2392    }
2393    const INT: usize = Self::USIZE;
2394}
2395
2396impl<U, B> ToInt<i8> for UInt<U, B>
2397where
2398    U: Unsigned,
2399    B: Bit,
2400{
2401    #[inline]
2402    fn to_int() -> i8 {
2403        Self::I8
2404    }
2405    const INT: i8 = Self::I8;
2406}
2407
2408impl<U, B> ToInt<i16> for UInt<U, B>
2409where
2410    U: Unsigned,
2411    B: Bit,
2412{
2413    #[inline]
2414    fn to_int() -> i16 {
2415        Self::I16
2416    }
2417    const INT: i16 = Self::I16;
2418}
2419
2420impl<U, B> ToInt<i32> for UInt<U, B>
2421where
2422    U: Unsigned,
2423    B: Bit,
2424{
2425    #[inline]
2426    fn to_int() -> i32 {
2427        Self::I32
2428    }
2429    const INT: i32 = Self::I32;
2430}
2431
2432impl<U, B> ToInt<i64> for UInt<U, B>
2433where
2434    U: Unsigned,
2435    B: Bit,
2436{
2437    #[inline]
2438    fn to_int() -> i64 {
2439        Self::I64
2440    }
2441    const INT: i64 = Self::I64;
2442}
2443
2444impl<U, B> ToInt<u8> for UInt<U, B>
2445where
2446    U: Unsigned,
2447    B: Bit,
2448{
2449    #[inline]
2450    fn to_int() -> u8 {
2451        Self::U8
2452    }
2453    const INT: u8 = Self::U8;
2454}
2455
2456impl<U, B> ToInt<u16> for UInt<U, B>
2457where
2458    U: Unsigned,
2459    B: Bit,
2460{
2461    #[inline]
2462    fn to_int() -> u16 {
2463        Self::U16
2464    }
2465    const INT: u16 = Self::U16;
2466}
2467
2468impl<U, B> ToInt<u32> for UInt<U, B>
2469where
2470    U: Unsigned,
2471    B: Bit,
2472{
2473    #[inline]
2474    fn to_int() -> u32 {
2475        Self::U32
2476    }
2477    const INT: u32 = Self::U32;
2478}
2479
2480impl<U, B> ToInt<u64> for UInt<U, B>
2481where
2482    U: Unsigned,
2483    B: Bit,
2484{
2485    #[inline]
2486    fn to_int() -> u64 {
2487        Self::U64
2488    }
2489    const INT: u64 = Self::U64;
2490}
2491
2492impl<U, B> ToInt<usize> for UInt<U, B>
2493where
2494    U: Unsigned,
2495    B: Bit,
2496{
2497    #[inline]
2498    fn to_int() -> usize {
2499        Self::USIZE
2500    }
2501    const INT: usize = Self::USIZE;
2502}
2503
2504#[cfg(test)]
2505mod tests {
2506    use crate::consts::*;
2507    use crate::{Log2, ToInt, Unsigned};
2508
2509    #[test]
2510    fn log2_test() {
2511        assert_eq!(0, <Log2<U1>>::to_u32());
2512
2513        assert_eq!(1, <Log2<U2>>::to_u32());
2514        assert_eq!(1, <Log2<U3>>::to_u32());
2515
2516        assert_eq!(2, <Log2<U4>>::to_u32());
2517        assert_eq!(2, <Log2<U5>>::to_u32());
2518        assert_eq!(2, <Log2<U6>>::to_u32());
2519        assert_eq!(2, <Log2<U7>>::to_u32());
2520
2521        assert_eq!(3, <Log2<U8>>::to_u32());
2522        assert_eq!(3, <Log2<U9>>::to_u32());
2523        assert_eq!(3, <Log2<U10>>::to_u32());
2524        assert_eq!(3, <Log2<U11>>::to_u32());
2525        assert_eq!(3, <Log2<U12>>::to_u32());
2526        assert_eq!(3, <Log2<U13>>::to_u32());
2527        assert_eq!(3, <Log2<U14>>::to_u32());
2528        assert_eq!(3, <Log2<U15>>::to_u32());
2529
2530        assert_eq!(4, <Log2<U16>>::to_u32());
2531        assert_eq!(4, <Log2<U17>>::to_u32());
2532        assert_eq!(4, <Log2<U18>>::to_u32());
2533        assert_eq!(4, <Log2<U19>>::to_u32());
2534        assert_eq!(4, <Log2<U20>>::to_u32());
2535        assert_eq!(4, <Log2<U21>>::to_u32());
2536        assert_eq!(4, <Log2<U22>>::to_u32());
2537        assert_eq!(4, <Log2<U23>>::to_u32());
2538        assert_eq!(4, <Log2<U24>>::to_u32());
2539        assert_eq!(4, <Log2<U25>>::to_u32());
2540        assert_eq!(4, <Log2<U26>>::to_u32());
2541        assert_eq!(4, <Log2<U27>>::to_u32());
2542        assert_eq!(4, <Log2<U28>>::to_u32());
2543        assert_eq!(4, <Log2<U29>>::to_u32());
2544        assert_eq!(4, <Log2<U30>>::to_u32());
2545        assert_eq!(4, <Log2<U31>>::to_u32());
2546
2547        assert_eq!(5, <Log2<U32>>::to_u32());
2548        assert_eq!(5, <Log2<U33>>::to_u32());
2549
2550        // ...
2551    }
2552
2553    #[test]
2554    fn uint_toint_test() {
2555        // i8
2556        assert_eq!(0_i8, U0::to_int());
2557        assert_eq!(1_i8, U1::to_int());
2558        assert_eq!(2_i8, U2::to_int());
2559        assert_eq!(3_i8, U3::to_int());
2560        assert_eq!(4_i8, U4::to_int());
2561        assert_eq!(0_i8, U0::INT);
2562        assert_eq!(1_i8, U1::INT);
2563        assert_eq!(2_i8, U2::INT);
2564        assert_eq!(3_i8, U3::INT);
2565        assert_eq!(4_i8, U4::INT);
2566
2567        // i16
2568        assert_eq!(0_i16, U0::to_int());
2569        assert_eq!(1_i16, U1::to_int());
2570        assert_eq!(2_i16, U2::to_int());
2571        assert_eq!(3_i16, U3::to_int());
2572        assert_eq!(4_i16, U4::to_int());
2573        assert_eq!(0_i16, U0::INT);
2574        assert_eq!(1_i16, U1::INT);
2575        assert_eq!(2_i16, U2::INT);
2576        assert_eq!(3_i16, U3::INT);
2577        assert_eq!(4_i16, U4::INT);
2578
2579        // i32
2580        assert_eq!(0_i32, U0::to_int());
2581        assert_eq!(1_i32, U1::to_int());
2582        assert_eq!(2_i32, U2::to_int());
2583        assert_eq!(3_i32, U3::to_int());
2584        assert_eq!(4_i32, U4::to_int());
2585        assert_eq!(0_i32, U0::INT);
2586        assert_eq!(1_i32, U1::INT);
2587        assert_eq!(2_i32, U2::INT);
2588        assert_eq!(3_i32, U3::INT);
2589        assert_eq!(4_i32, U4::INT);
2590
2591        // i64
2592        assert_eq!(0_i64, U0::to_int());
2593        assert_eq!(1_i64, U1::to_int());
2594        assert_eq!(2_i64, U2::to_int());
2595        assert_eq!(3_i64, U3::to_int());
2596        assert_eq!(4_i64, U4::to_int());
2597        assert_eq!(0_i64, U0::INT);
2598        assert_eq!(1_i64, U1::INT);
2599        assert_eq!(2_i64, U2::INT);
2600        assert_eq!(3_i64, U3::INT);
2601        assert_eq!(4_i64, U4::INT);
2602
2603        // u8
2604        assert_eq!(0_u8, U0::to_int());
2605        assert_eq!(1_u8, U1::to_int());
2606        assert_eq!(2_u8, U2::to_int());
2607        assert_eq!(3_u8, U3::to_int());
2608        assert_eq!(4_u8, U4::to_int());
2609        assert_eq!(0_u8, U0::INT);
2610        assert_eq!(1_u8, U1::INT);
2611        assert_eq!(2_u8, U2::INT);
2612        assert_eq!(3_u8, U3::INT);
2613        assert_eq!(4_u8, U4::INT);
2614
2615        // u16
2616        assert_eq!(0_u16, U0::to_int());
2617        assert_eq!(1_u16, U1::to_int());
2618        assert_eq!(2_u16, U2::to_int());
2619        assert_eq!(3_u16, U3::to_int());
2620        assert_eq!(4_u16, U4::to_int());
2621        assert_eq!(0_u16, U0::INT);
2622        assert_eq!(1_u16, U1::INT);
2623        assert_eq!(2_u16, U2::INT);
2624        assert_eq!(3_u16, U3::INT);
2625        assert_eq!(4_u16, U4::INT);
2626
2627        // u32
2628        assert_eq!(0_u32, U0::to_int());
2629        assert_eq!(1_u32, U1::to_int());
2630        assert_eq!(2_u32, U2::to_int());
2631        assert_eq!(3_u32, U3::to_int());
2632        assert_eq!(4_u32, U4::to_int());
2633        assert_eq!(0_u32, U0::INT);
2634        assert_eq!(1_u32, U1::INT);
2635        assert_eq!(2_u32, U2::INT);
2636        assert_eq!(3_u32, U3::INT);
2637        assert_eq!(4_u32, U4::INT);
2638
2639        // u64
2640        assert_eq!(0_u64, U0::to_int());
2641        assert_eq!(1_u64, U1::to_int());
2642        assert_eq!(2_u64, U2::to_int());
2643        assert_eq!(3_u64, U3::to_int());
2644        assert_eq!(4_u64, U4::to_int());
2645        assert_eq!(0_u64, U0::INT);
2646        assert_eq!(1_u64, U1::INT);
2647        assert_eq!(2_u64, U2::INT);
2648        assert_eq!(3_u64, U3::INT);
2649        assert_eq!(4_u64, U4::INT);
2650
2651        // usize
2652        assert_eq!(0_usize, U0::to_int());
2653        assert_eq!(1_usize, U1::to_int());
2654        assert_eq!(2_usize, U2::to_int());
2655        assert_eq!(3_usize, U3::to_int());
2656        assert_eq!(4_usize, U4::to_int());
2657        assert_eq!(0_usize, U0::INT);
2658        assert_eq!(1_usize, U1::INT);
2659        assert_eq!(2_usize, U2::INT);
2660        assert_eq!(3_usize, U3::INT);
2661        assert_eq!(4_usize, U4::INT);
2662    }
2663}
typenum/uint.rs

typenum/
uint.rs
