exint 0.1.4

An implementation of generic signed and unsigned integers.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

macro_rules! constants {
  (int) => {
    #[doc = include_doc!(int, "BITS")]
    pub const BITS: u32 = $crate::types::uint::<N>::BITS;

    #[doc = include_doc!(int, "MAX")]
    pub const MAX: Self = $crate::types::uint::<N>::MAX.const_shr(1).cast_signed();

    #[doc = include_doc!(int, "MIN")]
    pub const MIN: Self = Self::MAX.const_not();
  };
  (uint) => {
    #[doc = include_doc!(uint, "BITS")]
    pub const BITS: u32 = Self::MAX.count_ones();

    #[doc = include_doc!(uint, "MAX")]
    pub const MAX: Self = Self::MIN.const_not();

    #[doc = include_doc!(uint, "MIN")]
    pub const MIN: Self = Self::ZERO;
  };
  ($outer:ident, $inner:ident) => {
    #[doc = include_doc!($outer, $inner, "BITS")]
    pub const BITS: u32 = $crate::types::$inner::<N>::BITS;

    #[doc = include_doc!($outer, $inner, "MAX")]
    pub const MAX: Self = Self($crate::types::$inner::<N>::MAX);

    #[doc = include_doc!($outer, $inner, "MIN")]
    pub const MIN: Self = Self($crate::types::$inner::<N>::MIN);
  };
}

pub(crate) use constants;

// -----------------------------------------------------------------------------
// Tests
// -----------------------------------------------------------------------------

#[cfg(test)]
mod tests {
  use crate::tests::*;

  test!(test_bits, () => {
    assert_eq!(T::BITS, <T as IntExt>::BITS);
  });

  test!(@uint, test_min_uint, () => {
    assert_eq!(T::MIN, T::P_0);
  });

  test!(@uint, test_max_uint, () => {
    assert_eq!(T::MAX, T::P_2.wrapping_pow(T::BITS).wrapping_sub(T::P_1));
  });

  test!(@sint, test_min_sint, () => {
    assert_eq!(T::MIN, T::P_2.wrapping_pow(T::BITS - 1));
  });

  test!(@sint, test_max_sint, () => {
    assert_eq!(T::MAX, T::P_2.wrapping_pow(T::BITS - 1).wrapping_sub(T::P_1));
  });
}