numy 0.2.0

Trait boundaries for primitive Rust types
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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use crate::{Int, SignedInt};

/// Unsigned integers.
pub trait UnsignedInt: Int {
    /// The signed integer type with the same size.
    type S: SignedInt;

    /// Checked addition with a signed integer.
    #[must_use]
    fn checked_add_signed(self, rhs: Self::S) -> Option<Self>;

    /// Saturating addition with a signed integer.
    #[must_use]
    fn saturating_add_signed(self, rhs: Self::S) -> Self;

    /// Wrapping (modular) addition with a signed integer.
    #[must_use]
    fn wrapping_add_signed(self, rhs: Self::S) -> Self;

    /// Overflowing addition with a signed integer.
    #[must_use]
    fn overflowing_add_signed(self, rhs: Self::S) -> (Self, bool);

    /// Checked subtraction with a signed integer.
    #[must_use]
    fn checked_sub_signed(self, rhs: Self::S) -> Option<Self>;

    /// Saturating subtraction with a signed integer.
    #[must_use]
    fn saturating_sub_signed(self, rhs: Self::S) -> Self;

    /// Wrapping (modular) subtraction with a signed integer.
    #[must_use]
    fn wrapping_sub_signed(self, rhs: Self::S) -> Self;

    /// Overflowing subtraction with a signed integer.
    #[must_use]
    fn overflowing_sub_signed(self, rhs: Self::S) -> (Self, bool);

    /// Reinterpret bits as the signed integer of the same size.
    #[must_use]
    fn cast_signed(self) -> Self::S;
}

macro_rules! impl_unsigned_integer {
    ($($t:ty, $s:ty);* $(;)*) => {
        $(
            impl UnsignedInt for $t {
                type S = $s;

                #[inline(always)]
                fn checked_add_signed(self, rhs: Self::S) -> Option<Self> {
                    self.checked_add_signed(rhs)
                }

                #[inline(always)]
                fn saturating_add_signed(self, rhs: Self::S) -> Self {
                    self.saturating_add_signed(rhs)
                }

                #[inline(always)]
                fn wrapping_add_signed(self, rhs: Self::S) -> Self {
                    self.wrapping_add_signed(rhs)
                }

                #[inline(always)]
                fn overflowing_add_signed(self, rhs: Self::S) -> (Self, bool) {
                    self.overflowing_add_signed(rhs)
                }

                #[inline(always)]
                fn checked_sub_signed(self, rhs: Self::S) -> Option<Self> {
                    self.checked_sub_signed(rhs)
                }

                #[inline(always)]
                fn saturating_sub_signed(self, rhs: Self::S) -> Self {
                    self.saturating_sub_signed(rhs)
                }

                #[inline(always)]
                fn wrapping_sub_signed(self, rhs: Self::S) -> Self {
                    self.wrapping_sub_signed(rhs)
                }

                #[inline(always)]
                fn overflowing_sub_signed(self, rhs: Self::S) -> (Self, bool) {
                    self.overflowing_sub_signed(rhs)
                }

                #[inline(always)]
                fn cast_signed(self) -> Self::S {
                    self.cast_signed()
                }
            }
        )*
    };
}

impl_unsigned_integer!(
    u8, i8;
    u16, i16;
    u32, i32;
    u64, i64;
    u128, i128;
    usize, isize;
);