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

use super::{DivEuclid, DivRem, DivRemAssign, DivRemEuclid, RemEuclid};

macro_rules! impl_div_rem_ops_prim {
    ($($T:ty)*) => {$(
        impl DivRem for $T {
            type OutputDiv = $T;
            type OutputRem = $T;
            #[inline]
            fn div_rem(self, rhs: $T) -> ($T, $T) {
                (self / rhs, self % rhs)
            }
        }
        impl DivRemAssign for $T {
            type OutputRem = $T;
            #[inline]
            fn div_rem_assign(&mut self, rhs: $T) -> $T {
                let r = *self % rhs;
                *self /= rhs;
                r
            }
        }
        impl DivEuclid for $T {
            type Output = $T;
            #[inline]
            fn div_euclid(self, rhs: $T) -> $T {
                <$T>::div_euclid(self, rhs)
            }
        }
        impl RemEuclid for $T {
            type Output = $T;
            #[inline]
            fn rem_euclid(self, rhs: $T) -> $T {
                <$T>::rem_euclid(self, rhs)
            }
        }
        impl DivRemEuclid for $T {
            type OutputDiv = $T;
            type OutputRem = $T;
            #[inline]
            fn div_rem_euclid(self, rhs: $T) -> ($T, $T) {
                let (q, r) = (self / rhs, self % rhs);

                // depending on compiler to simplify the case for unsinged integers
                #[allow(unused_comparisons)]
                if r >= 0 {
                    (q, r)
                } else if rhs >= 0{
                    (q - 1, r + rhs)
                } else {
                    (q + 1, r - rhs)
                }
            }
        }
    )*}
}
impl_div_rem_ops_prim!(u8 u16 u32 u64 u128 usize i8 i16 i32 i64 i128 isize);

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

    #[test]
    fn test_simple() {
        assert_eq!(7u32.div_rem(4), (1, 3));
        assert_eq!(7u32.div_rem_euclid(4), (1, 3));
        assert_eq!(7i32.div_rem(-4), (-1, 3));
        assert_eq!(7i32.div_rem_euclid(-4), (-1, 3));
        assert_eq!((-7i32).div_rem(4), (-1, -3));
        assert_eq!((-7i32).div_rem_euclid(4), (-2, 1));
        assert_eq!((-7i32).div_rem(-4), (1, -3));
        assert_eq!((-7i32).div_rem_euclid(-4), (2, 1));

        let mut n = 7u32;
        let r = n.div_rem_assign(4);
        assert!(n == 1 && r == 3);
    }
}