nsw_types/
lib.rs

1//! # nsw-types - non-standard-width integers types
2//!
3//! When non-standard-width integers is required in an applications, the norm is to use a larger
4//! container and make sure the value is within range after manipulation. nsw-types aims to take
5//! care of this once and for all by:
6//!
7//! - Providing `u1`-`u127` and `i1`-`i127` types that should behave as similar as possible to the
8//!   built in rust types
9//!     - The methods of the defined types are the same as for the built in types (far from all is
10//!       implemented at this point but fill out an issue or create a PR if something essential for
11//!       you is missing)
12//!     - Overflow will panic in debug and wrap in release.
13//! - All possible infallible conversions is possible by using `From` and all fallible conversion by
14//!   using `TryFrom`.
15//!
16//! The types take up as much space as the smallest integer type that can contain them;
17//! the compiler can not yet be made aware of further optimization potential,
18//! and thus does not use it:
19//! an `Option<u7>` still takes up two bytes.
20
21#![cfg_attr(not(feature = "std"), no_std)]
22
23mod lib {
24    pub use core;
25}
26
27mod conversion;
28#[cfg(feature = "bitvec")]
29pub mod from_bitslice;
30#[cfg(feature = "num-traits")]
31pub mod num_traits_impls;
32pub mod trait_impls;
33#[cfg(feature = "num-traits")]
34pub use num_traits;
35
36use lib::core::ops::{
37    BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Not, Shl, ShlAssign, Shr,
38    ShrAssign,
39};
40
41use lib::core::fmt::{Binary, Display, Formatter, LowerHex, Octal, UpperHex};
42
43macro_rules! define_unsigned {
44    ($name:ident, $bits:expr, $type:ident) => {define_unsigned!(#[doc=""], $name, $bits, $type);};
45    (#[$doc:meta], $name:ident, $bits:expr, $type:ident) => {
46
47       #[$doc]
48        #[allow(non_camel_case_types)]
49        #[derive(Default, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
50        pub struct $name($type);
51
52        impl $name {
53            pub const MAX: Self = $name(((1 as $type) << $bits) -1 );
54            pub const MIN: Self = $name(0);
55            pub const BITS: u32 = $bits;
56
57            fn mask(self) -> Self {
58                $name(self.0 & ( ((1 as $type) << $bits).overflowing_sub(1).0))
59            }
60        }
61
62        implement_common!($name, $bits, $type);
63
64    }
65}
66
67macro_rules! define_signed {
68    ($name:ident, $bits:expr, $type:ident) => {define_signed!(#[doc=""], $name, $bits, $type);};
69    (#[$doc:meta], $name:ident, $bits:expr, $type:ident) => {
70
71        #[$doc]
72        #[allow(non_camel_case_types)]
73        #[derive(Default, Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
74        pub struct $name($type);
75
76        #[$doc]
77        impl $name {
78            pub const MAX: Self = $name(((1 as $type) << ($bits - 1)) - 1);
79            pub const MIN: Self = $name(-((1 as $type) << ($bits - 1)));
80            pub const BITS: u32 = $bits;
81
82            fn mask(self) -> Self {
83                if ( self.0 & (1<<($bits-1)) ) == 0 {
84                    $name(self.0 & ( ((1 as $type) << $bits).overflowing_sub(1).0))
85                } else {
86                    $name(self.0 | !( ((1 as $type) << $bits).overflowing_sub(1).0))
87                }
88            }
89        }
90
91        implement_common!($name, $bits, $type);
92
93    }
94}
95
96macro_rules! implement_common {
97    ($name:ident, $bits:expr, $type:ident) => {
98        impl $name {
99            /// Returns the smallest value that can be represented by this integer type.
100            pub fn min_value() -> $name {
101                $name::MIN
102            }
103            /// Returns the largest value that can be represented by this integer type.
104            pub fn max_value() -> $name {
105                $name::MAX
106            }
107
108            /// Crates a new variable
109            ///
110            /// This function mainly exists as there is currently not a better way to construct
111            /// these types. May be deprecated or removed if a better way to construct these
112            /// types becomes available.
113            ///
114            /// # Examples
115            ///
116            /// Basic usage:
117            ///
118            /// ```
119            /// use nsw_types::*;
120            ///
121            /// assert_eq!(u31::new(64), u31::from(64u8));
122            /// ```
123            ///
124            /// # Panic
125            ///
126            /// This function will panic if `value` is not representable by this type
127            pub const fn new(value: $type) -> $name {
128                assert!(value <= $name::MAX.0 && value >= $name::MIN.0);
129                $name(value)
130            }
131
132            /// Wrapping (modular) subtraction. Computes `self - other`,
133            /// wrapping around at the boundary of the type.
134            ///
135            /// # Examples
136            ///
137            /// Basic usage:
138            ///
139            /// ```
140            /// use nsw_types::*;
141            ///
142            /// assert_eq!(i5::MIN.wrapping_sub(i5::new(1)), i5::MAX);
143            ///
144            /// assert_eq!(i5::new(-10).wrapping_sub(i5::new(5)), i5::new(-15));
145            /// assert_eq!(i5::new(-15).wrapping_sub(i5::new(5)), i5::new(12));
146            /// ```
147            pub fn wrapping_sub(self, rhs: Self) -> Self {
148                $name(self.0.wrapping_sub(rhs.0)).mask()
149            }
150
151            /// Wrapping (modular) addition. Computes `self + other`,
152            /// wrapping around at the boundary of the type.
153            ///
154            /// # Examples
155            ///
156            /// Basic usage:
157            ///
158            /// ```
159            /// use nsw_types::*;
160            ///
161            /// assert_eq!(i5::MAX.wrapping_add(i5::new(1)), i5::MIN);
162            ///
163            /// assert_eq!(i5::new(10).wrapping_add(i5::new(5)), i5::new(15));
164            /// assert_eq!(i5::new(15).wrapping_add(i5::new(5)), i5::new(-12));
165            /// ```
166            pub fn wrapping_add(self, rhs: Self) -> Self {
167                $name(self.0.wrapping_add(rhs.0)).mask()
168            }
169        }
170
171        // Implement formating functions
172        impl Display for $name {
173            fn fmt(&self, f: &mut Formatter) -> Result<(), lib::core::fmt::Error> {
174                let $name(ref value) = self;
175                <$type as Display>::fmt(value, f)
176            }
177        }
178        impl UpperHex for $name {
179            fn fmt(&self, f: &mut Formatter) -> Result<(), lib::core::fmt::Error> {
180                let $name(ref value) = self;
181                <$type as UpperHex>::fmt(value, f)
182            }
183        }
184        impl LowerHex for $name {
185            fn fmt(&self, f: &mut Formatter) -> Result<(), lib::core::fmt::Error> {
186                let $name(ref value) = self;
187                <$type as LowerHex>::fmt(value, f)
188            }
189        }
190        impl Octal for $name {
191            fn fmt(&self, f: &mut Formatter) -> Result<(), lib::core::fmt::Error> {
192                let $name(ref value) = self;
193                <$type as Octal>::fmt(value, f)
194            }
195        }
196        impl Binary for $name {
197            fn fmt(&self, f: &mut Formatter) -> Result<(), lib::core::fmt::Error> {
198                let $name(ref value) = self;
199                <$type as Binary>::fmt(value, f)
200            }
201        }
202
203        impl<T> Shr<T> for $name
204        where
205            $type: Shr<T, Output = $type>,
206        {
207            type Output = $name;
208
209            fn shr(self, rhs: T) -> $name {
210                $name(self.0.shr(rhs))
211            }
212        }
213
214        impl<T> Shl<T> for $name
215        where
216            $type: Shl<T, Output = $type>,
217        {
218            type Output = $name;
219
220            fn shl(self, rhs: T) -> $name {
221                $name(self.0.shl(rhs)).mask()
222            }
223        }
224
225        impl<T> ShrAssign<T> for $name
226        where
227            $type: ShrAssign<T>,
228        {
229            fn shr_assign(&mut self, rhs: T) {
230                self.0.shr_assign(rhs);
231            }
232        }
233
234        impl<T> ShlAssign<T> for $name
235        where
236            $type: ShlAssign<T>,
237        {
238            fn shl_assign(&mut self, rhs: T) {
239                self.0.shl_assign(rhs);
240                *self = self.mask();
241            }
242        }
243
244        impl BitOr<$name> for $name {
245            type Output = $name;
246
247            fn bitor(self, rhs: $name) -> Self::Output {
248                $name(self.0.bitor(rhs.0))
249            }
250        }
251
252        impl<'a> BitOr<&'a $name> for $name {
253            type Output = <$name as BitOr<$name>>::Output;
254
255            fn bitor(self, rhs: &'a $name) -> Self::Output {
256                $name(self.0.bitor(rhs.0))
257            }
258        }
259
260        impl<'a> BitOr<$name> for &'a $name {
261            type Output = <$name as BitOr<$name>>::Output;
262
263            fn bitor(self, rhs: $name) -> Self::Output {
264                $name(self.0.bitor(rhs.0))
265            }
266        }
267
268        impl<'a> BitOr<&'a $name> for &'a $name {
269            type Output = <$name as BitOr<$name>>::Output;
270
271            fn bitor(self, rhs: &'a $name) -> Self::Output {
272                $name(self.0.bitor(rhs.0))
273            }
274        }
275
276        impl BitOrAssign<$name> for $name {
277            fn bitor_assign(&mut self, other: $name) {
278                self.0.bitor_assign(other.0)
279            }
280        }
281
282        impl BitXor<$name> for $name {
283            type Output = $name;
284
285            fn bitxor(self, rhs: $name) -> Self::Output {
286                $name(self.0.bitxor(rhs.0))
287            }
288        }
289
290        impl<'a> BitXor<&'a $name> for $name {
291            type Output = <$name as BitOr<$name>>::Output;
292
293            fn bitxor(self, rhs: &'a $name) -> Self::Output {
294                $name(self.0.bitxor(rhs.0))
295            }
296        }
297
298        impl<'a> BitXor<$name> for &'a $name {
299            type Output = <$name as BitOr<$name>>::Output;
300
301            fn bitxor(self, rhs: $name) -> Self::Output {
302                $name(self.0.bitxor(rhs.0))
303            }
304        }
305
306        impl<'a> BitXor<&'a $name> for &'a $name {
307            type Output = <$name as BitOr<$name>>::Output;
308
309            fn bitxor(self, rhs: &'a $name) -> Self::Output {
310                $name(self.0.bitxor(rhs.0))
311            }
312        }
313
314        impl BitXorAssign<$name> for $name {
315            fn bitxor_assign(&mut self, other: $name) {
316                self.0.bitxor_assign(other.0)
317            }
318        }
319
320        impl Not for $name {
321            type Output = $name;
322
323            fn not(self) -> $name {
324                $name(self.0.not()).mask()
325            }
326        }
327
328        impl<'a> Not for &'a $name {
329            type Output = <$name as Not>::Output;
330
331            fn not(self) -> $name {
332                $name(self.0.not()).mask()
333            }
334        }
335
336        impl BitAnd<$name> for $name {
337            type Output = $name;
338
339            fn bitand(self, rhs: $name) -> Self::Output {
340                $name(self.0.bitand(rhs.0))
341            }
342        }
343
344        impl<'a> BitAnd<&'a $name> for $name {
345            type Output = <$name as BitOr<$name>>::Output;
346
347            fn bitand(self, rhs: &'a $name) -> Self::Output {
348                $name(self.0.bitand(rhs.0))
349            }
350        }
351
352        impl<'a> BitAnd<$name> for &'a $name {
353            type Output = <$name as BitOr<$name>>::Output;
354
355            fn bitand(self, rhs: $name) -> Self::Output {
356                $name(self.0.bitand(rhs.0))
357            }
358        }
359
360        impl<'a> BitAnd<&'a $name> for &'a $name {
361            type Output = <$name as BitOr<$name>>::Output;
362
363            fn bitand(self, rhs: &'a $name) -> Self::Output {
364                $name(self.0.bitand(rhs.0))
365            }
366        }
367
368        impl BitAndAssign<$name> for $name {
369            fn bitand_assign(&mut self, other: $name) {
370                self.0.bitand_assign(other.0)
371            }
372        }
373
374        impl lib::core::ops::Add<$name> for $name {
375            type Output = $name;
376            #[allow(unused_comparisons)]
377            fn add(self, other: $name) -> $name {
378                if self.0 > 0 && other.0 > 0 {
379                    debug_assert!(Self::MAX.0 - other.0 >= self.0);
380                } else if self.0 < 0 && other.0 < 0 {
381                    debug_assert!(Self::MIN.0 - other.0 <= self.0);
382                }
383                self.wrapping_add(other)
384            }
385        }
386
387        impl lib::core::ops::Sub<$name> for $name {
388            type Output = $name;
389            #[allow(unused_comparisons)]
390            fn sub(self, other: $name) -> $name {
391                if self > other {
392                    debug_assert!(Self::MAX.0 + other.0 >= self.0);
393                } else if self < other {
394                    debug_assert!(Self::MIN.0 + other.0 <= self.0);
395                }
396                self.wrapping_sub(other)
397            }
398        }
399
400        impl lib::core::ops::Mul<$name> for $name {
401            type Output = $name;
402
403            fn mul(self, rhs: $name) -> Self::Output {
404                match self.0 * rhs.0 {
405                    v if v > Self::MAX.0 => panic!("attempt to multiply with overflow"),
406                    v => $name(v).mask(),
407                }
408            }
409        }
410    };
411}
412
413define_unsigned!(#[doc="The 1-bit unsigned integer type."], u1, 1, u8);
414define_unsigned!(#[doc="The 2-bit unsigned integer type."], u2, 2, u8);
415define_unsigned!(#[doc="The 3-bit unsigned integer type."], u3, 3, u8);
416define_unsigned!(#[doc="The 4-bit unsigned integer type."], u4, 4, u8);
417define_unsigned!(#[doc="The 5-bit unsigned integer type."], u5, 5, u8);
418define_unsigned!(#[doc="The 6-bit unsigned integer type."], u6, 6, u8);
419define_unsigned!(#[doc="The 7-bit unsigned integer type."], u7, 7, u8);
420
421define_unsigned!(#[doc="The 9-bit unsigned integer type."], u9, 9, u16);
422define_unsigned!(#[doc="The 10-bit unsigned integer type."], u10, 10, u16);
423define_unsigned!(#[doc="The 11-bit unsigned integer type."], u11, 11, u16);
424define_unsigned!(#[doc="The 12-bit unsigned integer type."], u12, 12, u16);
425define_unsigned!(#[doc="The 13-bit unsigned integer type."], u13, 13, u16);
426define_unsigned!(#[doc="The 14-bit unsigned integer type."], u14, 14, u16);
427define_unsigned!(#[doc="The 15-bit unsigned integer type."], u15, 15, u16);
428
429define_unsigned!(#[doc="The 17-bit unsigned integer type."], u17, 17, u32);
430define_unsigned!(#[doc="The 18-bit unsigned integer type."], u18, 18, u32);
431define_unsigned!(#[doc="The 19-bit unsigned integer type."], u19, 19, u32);
432define_unsigned!(#[doc="The 20-bit unsigned integer type."], u20, 20, u32);
433define_unsigned!(#[doc="The 21-bit unsigned integer type."], u21, 21, u32);
434define_unsigned!(#[doc="The 22-bit unsigned integer type."], u22, 22, u32);
435define_unsigned!(#[doc="The 23-bit unsigned integer type."], u23, 23, u32);
436define_unsigned!(#[doc="The 24-bit unsigned integer type."], u24, 24, u32);
437
438define_unsigned!(#[doc="The 25-bit unsigned integer type."], u25, 25, u32);
439define_unsigned!(#[doc="The 26-bit unsigned integer type."], u26, 26, u32);
440define_unsigned!(#[doc="The 27-bit unsigned integer type."], u27, 27, u32);
441define_unsigned!(#[doc="The 28-bit unsigned integer type."], u28, 28, u32);
442define_unsigned!(#[doc="The 29-bit unsigned integer type."], u29, 29, u32);
443define_unsigned!(#[doc="The 30-bit unsigned integer type."], u30, 30, u32);
444define_unsigned!(#[doc="The 31-bit unsigned integer type."], u31, 31, u32);
445
446define_unsigned!(#[doc="The 33-bit unsigned integer type."], u33, 33, u64);
447define_unsigned!(#[doc="The 34-bit unsigned integer type."], u34, 34, u64);
448define_unsigned!(#[doc="The 35-bit unsigned integer type."], u35, 35, u64);
449define_unsigned!(#[doc="The 36-bit unsigned integer type."], u36, 36, u64);
450define_unsigned!(#[doc="The 37-bit unsigned integer type."], u37, 37, u64);
451define_unsigned!(#[doc="The 38-bit unsigned integer type."], u38, 38, u64);
452define_unsigned!(#[doc="The 39-bit unsigned integer type."], u39, 39, u64);
453define_unsigned!(#[doc="The 40-bit unsigned integer type."], u40, 40, u64);
454
455define_unsigned!(#[doc="The 41-bit unsigned integer type."], u41, 41, u64);
456define_unsigned!(#[doc="The 42-bit unsigned integer type."], u42, 42, u64);
457define_unsigned!(#[doc="The 43-bit unsigned integer type."], u43, 43, u64);
458define_unsigned!(#[doc="The 44-bit unsigned integer type."], u44, 44, u64);
459define_unsigned!(#[doc="The 45-bit unsigned integer type."], u45, 45, u64);
460define_unsigned!(#[doc="The 46-bit unsigned integer type."], u46, 46, u64);
461define_unsigned!(#[doc="The 47-bit unsigned integer type."], u47, 47, u64);
462define_unsigned!(#[doc="The 48-bit unsigned integer type."], u48, 48, u64);
463
464define_unsigned!(#[doc="The 49-bit unsigned integer type."], u49, 49, u64);
465define_unsigned!(#[doc="The 50-bit unsigned integer type."], u50, 50, u64);
466define_unsigned!(#[doc="The 51-bit unsigned integer type."], u51, 51, u64);
467define_unsigned!(#[doc="The 52-bit unsigned integer type."], u52, 52, u64);
468define_unsigned!(#[doc="The 53-bit unsigned integer type."], u53, 53, u64);
469define_unsigned!(#[doc="The 54-bit unsigned integer type."], u54, 54, u64);
470define_unsigned!(#[doc="The 55-bit unsigned integer type."], u55, 55, u64);
471define_unsigned!(#[doc="The 56-bit unsigned integer type."], u56, 56, u64);
472
473define_unsigned!(#[doc="The 57-bit unsigned integer type."], u57, 57, u64);
474define_unsigned!(#[doc="The 58-bit unsigned integer type."], u58, 58, u64);
475define_unsigned!(#[doc="The 59-bit unsigned integer type."], u59, 59, u64);
476define_unsigned!(#[doc="The 60-bit unsigned integer type."], u60, 60, u64);
477define_unsigned!(#[doc="The 61-bit unsigned integer type."], u61, 61, u64);
478define_unsigned!(#[doc="The 62-bit unsigned integer type."], u62, 62, u64);
479define_unsigned!(#[doc="The 63-bit unsigned integer type."], u63, 63, u64);
480
481define_unsigned!(#[doc="The 65-bit unsigned integer type."], u65, 65, u128);
482define_unsigned!(#[doc="The 66-bit unsigned integer type."], u66, 66, u128);
483define_unsigned!(#[doc="The 67-bit unsigned integer type."], u67, 67, u128);
484define_unsigned!(#[doc="The 68-bit unsigned integer type."], u68, 68, u128);
485define_unsigned!(#[doc="The 69-bit unsigned integer type."], u69, 69, u128);
486define_unsigned!(#[doc="The 70-bit unsigned integer type."], u70, 70, u128);
487define_unsigned!(#[doc="The 71-bit unsigned integer type."], u71, 71, u128);
488define_unsigned!(#[doc="The 72-bit unsigned integer type."], u72, 72, u128);
489
490define_unsigned!(#[doc="The 73-bit unsigned integer type."], u73, 73, u128);
491define_unsigned!(#[doc="The 74-bit unsigned integer type."], u74, 74, u128);
492define_unsigned!(#[doc="The 75-bit unsigned integer type."], u75, 75, u128);
493define_unsigned!(#[doc="The 76-bit unsigned integer type."], u76, 76, u128);
494define_unsigned!(#[doc="The 77-bit unsigned integer type."], u77, 77, u128);
495define_unsigned!(#[doc="The 78-bit unsigned integer type."], u78, 78, u128);
496define_unsigned!(#[doc="The 79-bit unsigned integer type."], u79, 79, u128);
497define_unsigned!(#[doc="The 80-bit unsigned integer type."], u80, 80, u128);
498
499define_unsigned!(#[doc="The 81-bit unsigned integer type."], u81, 81, u128);
500define_unsigned!(#[doc="The 82-bit unsigned integer type."], u82, 82, u128);
501define_unsigned!(#[doc="The 83-bit unsigned integer type."], u83, 83, u128);
502define_unsigned!(#[doc="The 84-bit unsigned integer type."], u84, 84, u128);
503define_unsigned!(#[doc="The 85-bit unsigned integer type."], u85, 85, u128);
504define_unsigned!(#[doc="The 86-bit unsigned integer type."], u86, 86, u128);
505define_unsigned!(#[doc="The 87-bit unsigned integer type."], u87, 87, u128);
506define_unsigned!(#[doc="The 88-bit unsigned integer type."], u88, 88, u128);
507
508define_unsigned!(#[doc="The 89-bit unsigned integer type."], u89, 89, u128);
509define_unsigned!(#[doc="The 90-bit unsigned integer type."], u90, 90, u128);
510define_unsigned!(#[doc="The 91-bit unsigned integer type."], u91, 91, u128);
511define_unsigned!(#[doc="The 92-bit unsigned integer type."], u92, 92, u128);
512define_unsigned!(#[doc="The 93-bit unsigned integer type."], u93, 93, u128);
513define_unsigned!(#[doc="The 94-bit unsigned integer type."], u94, 94, u128);
514define_unsigned!(#[doc="The 95-bit unsigned integer type."], u95, 95, u128);
515define_unsigned!(#[doc="The 96-bit unsigned integer type."], u96, 96, u128);
516
517define_unsigned!(#[doc="The 97-bit unsigned integer type."], u97, 97, u128);
518define_unsigned!(#[doc="The 98-bit unsigned integer type."], u98, 98, u128);
519define_unsigned!(#[doc="The 99-bit unsigned integer type."], u99, 99, u128);
520define_unsigned!(#[doc="The 100-bit unsigned integer type."], u100, 100, u128);
521define_unsigned!(#[doc="The 101-bit unsigned integer type."], u101, 101, u128);
522define_unsigned!(#[doc="The 102-bit unsigned integer type."], u102, 102, u128);
523define_unsigned!(#[doc="The 103-bit unsigned integer type."], u103, 103, u128);
524define_unsigned!(#[doc="The 104-bit unsigned integer type."], u104, 104, u128);
525
526define_unsigned!(#[doc="The 105-bit unsigned integer type."], u105, 105, u128);
527define_unsigned!(#[doc="The 106-bit unsigned integer type."], u106, 106, u128);
528define_unsigned!(#[doc="The 107-bit unsigned integer type."], u107, 107, u128);
529define_unsigned!(#[doc="The 108-bit unsigned integer type."], u108, 108, u128);
530define_unsigned!(#[doc="The 109-bit unsigned integer type."], u109, 109, u128);
531define_unsigned!(#[doc="The 110-bit unsigned integer type."], u110, 110, u128);
532define_unsigned!(#[doc="The 111-bit unsigned integer type."], u111, 111, u128);
533define_unsigned!(#[doc="The 112-bit unsigned integer type."], u112, 112, u128);
534
535define_unsigned!(#[doc="The 113-bit unsigned integer type."], u113, 113, u128);
536define_unsigned!(#[doc="The 114-bit unsigned integer type."], u114, 114, u128);
537define_unsigned!(#[doc="The 115-bit unsigned integer type."], u115, 115, u128);
538define_unsigned!(#[doc="The 116-bit unsigned integer type."], u116, 116, u128);
539define_unsigned!(#[doc="The 117-bit unsigned integer type."], u117, 117, u128);
540define_unsigned!(#[doc="The 118-bit unsigned integer type."], u118, 118, u128);
541define_unsigned!(#[doc="The 119-bit unsigned integer type."], u119, 119, u128);
542define_unsigned!(#[doc="The 120-bit unsigned integer type."], u120, 120, u128);
543
544define_unsigned!(#[doc="The 121-bit unsigned integer type."], u121, 121, u128);
545define_unsigned!(#[doc="The 122-bit unsigned integer type."], u122, 122, u128);
546define_unsigned!(#[doc="The 123-bit unsigned integer type."], u123, 123, u128);
547define_unsigned!(#[doc="The 124-bit unsigned integer type."], u124, 124, u128);
548define_unsigned!(#[doc="The 125-bit unsigned integer type."], u125, 125, u128);
549define_unsigned!(#[doc="The 126-bit unsigned integer type."], u126, 126, u128);
550define_unsigned!(#[doc="The 127-bit unsigned integer type."], u127, 127, u128);
551
552define_signed!(#[doc="The 1-bit signed integer type."], i1, 1, i8);
553define_signed!(#[doc="The 2-bit signed integer type."], i2, 2, i8);
554define_signed!(#[doc="The 3-bit signed integer type."], i3, 3, i8);
555define_signed!(#[doc="The 4-bit signed integer type."], i4, 4, i8);
556define_signed!(#[doc="The 5-bit signed integer type."], i5, 5, i8);
557define_signed!(#[doc="The 6-bit signed integer type."], i6, 6, i8);
558define_signed!(#[doc="The 7-bit signed integer type."], i7, 7, i8);
559
560define_signed!(#[doc="The 9-bit signed integer type."], i9, 9, i16);
561define_signed!(#[doc="The 10-bit signed integer type."], i10, 10, i16);
562define_signed!(#[doc="The 11-bit signed integer type."], i11, 11, i16);
563define_signed!(#[doc="The 12-bit signed integer type."], i12, 12, i16);
564define_signed!(#[doc="The 13-bit signed integer type."], i13, 13, i16);
565define_signed!(#[doc="The 14-bit signed integer type."], i14, 14, i16);
566define_signed!(#[doc="The 15-bit signed integer type."], i15, 15, i16);
567
568define_signed!(#[doc="The 17-bit signed integer type."], i17, 17, i32);
569define_signed!(#[doc="The 18-bit signed integer type."], i18, 18, i32);
570define_signed!(#[doc="The 19-bit signed integer type."], i19, 19, i32);
571define_signed!(#[doc="The 20-bit signed integer type."], i20, 20, i32);
572define_signed!(#[doc="The 21-bit signed integer type."], i21, 21, i32);
573define_signed!(#[doc="The 22-bit signed integer type."], i22, 22, i32);
574define_signed!(#[doc="The 23-bit signed integer type."], i23, 23, i32);
575define_signed!(#[doc="The 24-bit signed integer type."], i24, 24, i32);
576
577define_signed!(#[doc="The 25-bit signed integer type."], i25, 25, i32);
578define_signed!(#[doc="The 26-bit signed integer type."], i26, 26, i32);
579define_signed!(#[doc="The 27-bit signed integer type."], i27, 27, i32);
580define_signed!(#[doc="The 28-bit signed integer type."], i28, 28, i32);
581define_signed!(#[doc="The 29-bit signed integer type."], i29, 29, i32);
582define_signed!(#[doc="The 30-bit signed integer type."], i30, 30, i32);
583define_signed!(#[doc="The 31-bit signed integer type."], i31, 31, i32);
584
585define_signed!(#[doc="The 33-bit signed integer type."], i33, 33, i64);
586define_signed!(#[doc="The 34-bit signed integer type."], i34, 34, i64);
587define_signed!(#[doc="The 35-bit signed integer type."], i35, 35, i64);
588define_signed!(#[doc="The 36-bit signed integer type."], i36, 36, i64);
589define_signed!(#[doc="The 37-bit signed integer type."], i37, 37, i64);
590define_signed!(#[doc="The 38-bit signed integer type."], i38, 38, i64);
591define_signed!(#[doc="The 39-bit signed integer type."], i39, 39, i64);
592define_signed!(#[doc="The 40-bit signed integer type."], i40, 40, i64);
593
594define_signed!(#[doc="The 41-bit signed integer type."], i41, 41, i64);
595define_signed!(#[doc="The 42-bit signed integer type."], i42, 42, i64);
596define_signed!(#[doc="The 43-bit signed integer type."], i43, 43, i64);
597define_signed!(#[doc="The 44-bit signed integer type."], i44, 44, i64);
598define_signed!(#[doc="The 45-bit signed integer type."], i45, 45, i64);
599define_signed!(#[doc="The 46-bit signed integer type."], i46, 46, i64);
600define_signed!(#[doc="The 47-bit signed integer type."], i47, 47, i64);
601define_signed!(#[doc="The 48-bit signed integer type."], i48, 48, i64);
602
603define_signed!(#[doc="The 49-bit signed integer type."], i49, 49, i64);
604define_signed!(#[doc="The 50-bit signed integer type."], i50, 50, i64);
605define_signed!(#[doc="The 51-bit signed integer type."], i51, 51, i64);
606define_signed!(#[doc="The 52-bit signed integer type."], i52, 52, i64);
607define_signed!(#[doc="The 53-bit signed integer type."], i53, 53, i64);
608define_signed!(#[doc="The 54-bit signed integer type."], i54, 54, i64);
609define_signed!(#[doc="The 55-bit signed integer type."], i55, 55, i64);
610define_signed!(#[doc="The 56-bit signed integer type."], i56, 56, i64);
611
612define_signed!(#[doc="The 57-bit signed integer type."], i57, 57, i64);
613define_signed!(#[doc="The 58-bit signed integer type."], i58, 58, i64);
614define_signed!(#[doc="The 59-bit signed integer type."], i59, 59, i64);
615define_signed!(#[doc="The 60-bit signed integer type."], i60, 60, i64);
616define_signed!(#[doc="The 61-bit signed integer type."], i61, 61, i64);
617define_signed!(#[doc="The 62-bit signed integer type."], i62, 62, i64);
618define_signed!(#[doc="The 63-bit signed integer type."], i63, 63, i64);
619
620define_signed!(#[doc="The 65-bit signed integer type."], i65, 65, i128);
621define_signed!(#[doc="The 66-bit signed integer type."], i66, 66, i128);
622define_signed!(#[doc="The 67-bit signed integer type."], i67, 67, i128);
623define_signed!(#[doc="The 68-bit signed integer type."], i68, 68, i128);
624define_signed!(#[doc="The 69-bit signed integer type."], i69, 69, i128);
625define_signed!(#[doc="The 70-bit signed integer type."], i70, 70, i128);
626define_signed!(#[doc="The 71-bit signed integer type."], i71, 71, i128);
627define_signed!(#[doc="The 72-bit signed integer type."], i72, 72, i128);
628
629define_signed!(#[doc="The 73-bit signed integer type."], i73, 73, i128);
630define_signed!(#[doc="The 74-bit signed integer type."], i74, 74, i128);
631define_signed!(#[doc="The 75-bit signed integer type."], i75, 75, i128);
632define_signed!(#[doc="The 76-bit signed integer type."], i76, 76, i128);
633define_signed!(#[doc="The 77-bit signed integer type."], i77, 77, i128);
634define_signed!(#[doc="The 78-bit signed integer type."], i78, 78, i128);
635define_signed!(#[doc="The 79-bit signed integer type."], i79, 79, i128);
636define_signed!(#[doc="The 80-bit signed integer type."], i80, 80, i128);
637
638define_signed!(#[doc="The 81-bit signed integer type."], i81, 81, i128);
639define_signed!(#[doc="The 82-bit signed integer type."], i82, 82, i128);
640define_signed!(#[doc="The 83-bit signed integer type."], i83, 83, i128);
641define_signed!(#[doc="The 84-bit signed integer type."], i84, 84, i128);
642define_signed!(#[doc="The 85-bit signed integer type."], i85, 85, i128);
643define_signed!(#[doc="The 86-bit signed integer type."], i86, 86, i128);
644define_signed!(#[doc="The 87-bit signed integer type."], i87, 87, i128);
645define_signed!(#[doc="The 88-bit signed integer type."], i88, 88, i128);
646
647define_signed!(#[doc="The 89-bit signed integer type."], i89, 89, i128);
648define_signed!(#[doc="The 90-bit signed integer type."], i90, 90, i128);
649define_signed!(#[doc="The 91-bit signed integer type."], i91, 91, i128);
650define_signed!(#[doc="The 92-bit signed integer type."], i92, 92, i128);
651define_signed!(#[doc="The 93-bit signed integer type."], i93, 93, i128);
652define_signed!(#[doc="The 94-bit signed integer type."], i94, 94, i128);
653define_signed!(#[doc="The 95-bit signed integer type."], i95, 95, i128);
654define_signed!(#[doc="The 96-bit signed integer type."], i96, 96, i128);
655
656define_signed!(#[doc="The 97-bit signed integer type."], i97, 97, i128);
657define_signed!(#[doc="The 98-bit signed integer type."], i98, 98, i128);
658define_signed!(#[doc="The 99-bit signed integer type."], i99, 99, i128);
659define_signed!(#[doc="The 100-bit signed integer type."], i100, 100, i128);
660define_signed!(#[doc="The 101-bit signed integer type."], i101, 101, i128);
661define_signed!(#[doc="The 102-bit signed integer type."], i102, 102, i128);
662define_signed!(#[doc="The 103-bit signed integer type."], i103, 103, i128);
663define_signed!(#[doc="The 104-bit signed integer type."], i104, 104, i128);
664
665define_signed!(#[doc="The 105-bit signed integer type."], i105, 105, i128);
666define_signed!(#[doc="The 106-bit signed integer type."], i106, 106, i128);
667define_signed!(#[doc="The 107-bit signed integer type."], i107, 107, i128);
668define_signed!(#[doc="The 108-bit signed integer type."], i108, 108, i128);
669define_signed!(#[doc="The 109-bit signed integer type."], i109, 109, i128);
670define_signed!(#[doc="The 110-bit signed integer type."], i110, 110, i128);
671define_signed!(#[doc="The 111-bit signed integer type."], i111, 111, i128);
672define_signed!(#[doc="The 112-bit signed integer type."], i112, 112, i128);
673
674define_signed!(#[doc="The 113-bit signed integer type."], i113, 113, i128);
675define_signed!(#[doc="The 114-bit signed integer type."], i114, 114, i128);
676define_signed!(#[doc="The 115-bit signed integer type."], i115, 115, i128);
677define_signed!(#[doc="The 116-bit signed integer type."], i116, 116, i128);
678define_signed!(#[doc="The 117-bit signed integer type."], i117, 117, i128);
679define_signed!(#[doc="The 118-bit signed integer type."], i118, 118, i128);
680define_signed!(#[doc="The 119-bit signed integer type."], i119, 119, i128);
681define_signed!(#[doc="The 120-bit signed integer type."], i120, 120, i128);
682
683define_signed!(#[doc="The 121-bit signed integer type."], i121, 121, i128);
684define_signed!(#[doc="The 122-bit signed integer type."], i122, 122, i128);
685define_signed!(#[doc="The 123-bit signed integer type."], i123, 123, i128);
686define_signed!(#[doc="The 124-bit signed integer type."], i124, 124, i128);
687define_signed!(#[doc="The 125-bit signed integer type."], i125, 125, i128);
688define_signed!(#[doc="The 126-bit signed integer type."], i126, 126, i128);
689define_signed!(#[doc="The 127-bit signed integer type."], i127, 127, i128);
690
691#[cfg(test)]
692mod tests {
693    use super::*;
694
695    #[test]
696    fn test_masking() {
697        assert_eq!(u4(0b11000110).mask().0, 0b00000110);
698        assert_eq!(u4(0b00001000).mask().0, 0b00001000);
699        assert_eq!(u4(0b00001110).mask().0, 0b00001110);
700
701        assert_eq!(i4(0b11000110u8 as i8).mask().0, 0b00000110u8 as i8);
702        assert_eq!(i4(0b00001000u8 as i8).mask().0, 0b11111000u8 as i8);
703        assert_eq!(i4(0b00001110u8 as i8).mask().0, 0b11111110u8 as i8);
704    }
705
706    #[test]
707    fn min_max_values() {
708        assert_eq!(u1::MAX, u1(1));
709        assert_eq!(u2::MAX, u2(3));
710        assert_eq!(u3::MAX, u3(7));
711        assert_eq!(u7::MAX, u7(127));
712        assert_eq!(u9::MAX, u9(511));
713
714        assert_eq!(i1::MAX, i1(0));
715        assert_eq!(i2::MAX, i2(1));
716        assert_eq!(i3::MAX, i3(3));
717        assert_eq!(i7::MAX, i7(63));
718        assert_eq!(i9::MAX, i9(255));
719
720        assert_eq!(u1::MIN, u1(0));
721        assert_eq!(u2::MIN, u2(0));
722        assert_eq!(u3::MIN, u3(0));
723        assert_eq!(u7::MIN, u7(0));
724        assert_eq!(u9::MIN, u9(0));
725        assert_eq!(u127::MIN, u127(0));
726
727        assert_eq!(i1::MIN, i1(-1));
728        assert_eq!(i2::MIN, i2(-2));
729        assert_eq!(i3::MIN, i3(-4));
730        assert_eq!(i7::MIN, i7(-64));
731        assert_eq!(i9::MIN, i9(-256));
732    }
733
734    #[test]
735    fn test_bits_values() {
736        assert_eq!(u1::BITS, 1);
737        assert_eq!(i7::BITS, 7);
738        assert_eq!(u127::BITS, 127);
739    }
740
741    #[test]
742    fn test_wrapping_add() {
743        assert_eq!(u1::MAX.wrapping_add(u1(1)), u1(0));
744        assert_eq!(u1::MAX.wrapping_add(u1(0)), u1(1));
745
746        assert_eq!(u5::MAX.wrapping_add(u5(1)), u5(0));
747        assert_eq!(u5::MAX.wrapping_add(u5(4)), u5(3));
748
749        assert_eq!(u127::MAX.wrapping_add(u127(100)), u127(99));
750        assert_eq!(u127::MAX.wrapping_add(u127(1)), u127(0));
751
752        assert_eq!(i1::MAX.wrapping_add(i1(0)), i1(0));
753        assert_eq!(i1::MAX.wrapping_add(i1(-1)), i1(-1));
754
755        assert_eq!(i7::MAX.wrapping_add(i7(1)), i7::MIN);
756        assert_eq!(i7::MAX.wrapping_add(i7(4)), i7(-61));
757    }
758
759    #[test]
760    fn test_wrapping_sub() {
761        assert_eq!(u1::MIN.wrapping_sub(u1(1)), u1(1));
762        assert_eq!(u3(1).wrapping_sub(u3(2)), u3::MAX);
763    }
764
765    #[test]
766    #[should_panic]
767    fn test_add_overflow_u5() {
768        let _s = u5::MAX + u5(1);
769    }
770
771    #[test]
772    #[should_panic]
773    fn test_add_overflow_u127() {
774        let _s = u127::MAX + u127(1);
775    }
776
777    #[test]
778    #[should_panic]
779    fn test_add_overflow_i96() {
780        let _s = i96::MAX + i96(100);
781    }
782
783    #[test]
784    #[should_panic]
785    fn test_add_underflow_i96() {
786        let _s = i96::MIN + i96(-100);
787    }
788
789    #[test]
790    #[should_panic]
791    fn test_add_underflow_i17() {
792        let _s = i17::MIN + i17(-1);
793    }
794
795    #[test]
796    fn test_add() {
797        assert_eq!(u5(1) + u5(2), u5(3));
798
799        assert_eq!(i7::MAX + i7::MIN, i7(-1));
800        assert_eq!(i7(4) + i7(-3), i7(1));
801        assert_eq!(i7(-4) + i7(3), i7(-1));
802        assert_eq!(i7(-3) + i7(-20), i7(-23));
803    }
804
805    #[test]
806    #[should_panic]
807    fn test_sub_overflow_i23() {
808        let _s = i23::MIN - i23::MAX;
809    }
810
811    #[test]
812    #[should_panic]
813    fn test_sub_underflow_u5() {
814        let _s = u5::MIN - u5(1);
815    }
816
817    #[test]
818    #[should_panic]
819    fn test_sub_underflow_i5() {
820        let _s = i5::MIN - i5(1);
821    }
822
823    #[test]
824    fn test_sub() {
825        assert_eq!(u5(1) - u5(1), u5(0));
826        assert_eq!(u5(3) - u5(2), u5(1));
827
828        assert_eq!(i1(-1) - i1(-1), i1(0));
829        assert_eq!(i7::MIN - i7::MIN, i7(0));
830        assert_eq!(i7(4) - i7(-3), i7(7));
831        assert_eq!(i7(-4) - i7(3), i7(-7));
832        assert_eq!(i7(-3) - i7(-20), i7(17));
833    }
834
835    #[test]
836    fn test_shr() {
837        assert_eq!(u5(8) >> 1usize, u5(4));
838        assert_eq!(u5(8) >> 1u8, u5(4));
839        assert_eq!(u5(8) >> 1u16, u5(4));
840        assert_eq!(u5(8) >> 1u32, u5(4));
841        assert_eq!(u5(8) >> 1u64, u5(4));
842        assert_eq!(u5(8) >> 1isize, u5(4));
843        assert_eq!(u5(8) >> 1i8, u5(4));
844        assert_eq!(u5(8) >> 1i16, u5(4));
845        assert_eq!(u5(8) >> 1i32, u5(4));
846        assert_eq!(u5(8) >> 1i64, u5(4));
847
848        assert_eq!(u5::MAX >> 4, u5(1));
849
850        assert_eq!(i7(-1) >> 5, i7(-1));
851    }
852
853    #[test]
854    fn test_shl() {
855        assert_eq!(u5(16) << 1usize, u5(0));
856        assert_eq!(u5(16) << 1u8, u5(0));
857        assert_eq!(u5(16) << 1u16, u5(0));
858        assert_eq!(u5(16) << 1u32, u5(0));
859        assert_eq!(u5(16) << 1u64, u5(0));
860        assert_eq!(u5(16) << 1isize, u5(0));
861        assert_eq!(u5(16) << 1i8, u5(0));
862        assert_eq!(u5(16) << 1i16, u5(0));
863        assert_eq!(u5(16) << 1i32, u5(0));
864        assert_eq!(u5(16) << 1i64, u5(0));
865
866        assert_eq!(u5::MAX << 4, u5(16));
867
868        assert_eq!(i5(16) << 1, i5(0));
869        assert_eq!(i7(1) << 3, i7(8));
870    }
871
872    #[test]
873    fn test_shr_assign() {
874        let mut x = u10(512);
875        x >>= 1usize;
876        assert_eq!(x, u10(256));
877        x >>= 1isize;
878        assert_eq!(x, u10(128));
879        x >>= 1u8;
880        assert_eq!(x, u10(64));
881        x >>= 1i8;
882        assert_eq!(x, u10(32));
883        x >>= 2u64;
884        assert_eq!(x, u10(8));
885        x >>= 3i32;
886        assert_eq!(x, u10(1));
887    }
888
889    #[test]
890    fn test_shl_assign() {
891        let mut x = u9(1);
892        x <<= 3i32;
893        assert_eq!(x, u9(8));
894        x <<= 2u64;
895        assert_eq!(x, u9(32));
896        x <<= 1usize;
897        assert_eq!(x, u9(64));
898        x <<= 1isize;
899        assert_eq!(x, u9(128));
900        x <<= 1u8;
901        assert_eq!(x, u9(256));
902        x <<= 1u8;
903        assert_eq!(x, u9(0));
904    }
905
906    #[test]
907    #[allow(clippy::op_ref)]
908    fn test_bitor() {
909        assert_eq!(u9(1) | u9(8), u9(9));
910        assert_eq!(&u9(1) | u9(8), u9(9));
911        assert_eq!(u9(1) | &u9(8), u9(9));
912        assert_eq!(&u9(1) | &u9(8), u9(9));
913    }
914
915    #[test]
916    fn test_bitor_assign() {
917        let mut x = u12(4);
918        x |= u12(1);
919        assert_eq!(x, u12(5));
920        x |= u12(128);
921        assert_eq!(x, u12(133));
922        x = u12(1);
923        x |= u12(127);
924        assert_eq!(x, u12(127));
925    }
926
927    #[test]
928    #[allow(clippy::op_ref)]
929    fn test_bitxor() {
930        assert_eq!(u7(0x7F) ^ u7(42), u7(85));
931        assert_eq!(&u7(0) ^ u7(42), u7(42));
932        assert_eq!(u7(0x10) ^ &u7(0x1), u7(0x11));
933        assert_eq!(&u7(11) ^ &u7(1), u7(10));
934    }
935
936    #[test]
937    fn test_bitxor_assign() {
938        let mut x = u12(4);
939        x ^= u12(1);
940        assert_eq!(x, u12(5));
941        x ^= u12(128);
942        assert_eq!(x, u12(133));
943        x ^= u12(1);
944        assert_eq!(x, u12(132));
945        x ^= u12(127);
946        assert_eq!(x, u12(251));
947    }
948
949    #[test]
950    #[allow(clippy::op_ref)]
951    fn test_bitand() {
952        assert_eq!(i9(-7) & i9(-9), i9::from(-7i8 & -9i8));
953        assert_eq!(&i9(-7) & i9(-9), i9::from(&-7i8 & -9i8));
954        assert_eq!(i9(-7) & &i9(-9), i9::from(-7i8 & &-9i8));
955        assert_eq!(&i9(-7) & &i9(-9), i9::from(&-7i8 & &-9i8));
956
957        assert_eq!(u9(8) & u9(9), u9(8));
958        assert_eq!(&u9(8) & u9(9), u9(8));
959        assert_eq!(u9(8) & &u9(9), u9(8));
960        assert_eq!(&u9(8) & &u9(9), u9(8));
961    }
962
963    #[test]
964    fn test_bitand_assign() {
965        let mut x = u12(255);
966        x &= u12(127);
967        assert_eq!(x, u12(127));
968        x &= u12(7);
969        assert_eq!(x, u12(7));
970        x &= u12(127);
971        assert_eq!(x, u12(7));
972        x &= u12(4);
973        assert_eq!(x, u12(4));
974    }
975
976    #[test]
977    fn test_not() {
978        assert_eq!(!u7(42), u7(85));
979        assert_eq!(!u7(0x7F), u7(0));
980        assert_eq!(!u7(0), u7(0x7F));
981        assert_eq!(!u7(56), u7(71));
982    }
983
984    #[test]
985    #[allow(clippy::single_match)]
986    fn test_match() {
987        const SEVEN: u7 = u7::new(7);
988        match u7(7) {
989            SEVEN => (),
990            _ => panic!("Pattern matching failed (7 != 7?)"),
991        }
992        match u7(42) {
993            SEVEN => panic!("Pattern matching failed (7 == 42?)"),
994            _ => (),
995        }
996    }
997
998    #[test]
999    fn test_mul() {
1000        assert_eq!(u1(1) * u1(1), u1(1));
1001        assert_eq!(u7(63) * u7(2), u7(126));
1002    }
1003}
nsw_types/lib.rs

nsw_types/
lib.rs
