num_traits/ops/
wrapping.rs

1use core::num::Wrapping;
2use core::ops::{Add, Mul, Neg, Shl, Shr, Sub};
3
4macro_rules! wrapping_impl {
5    ($trait_name:ident, $method:ident, $t:ty) => {
6        impl $trait_name for $t {
7            #[inline]
8            fn $method(&self, v: &Self) -> Self {
9                <$t>::$method(*self, *v)
10            }
11        }
12    };
13    ($trait_name:ident, $method:ident, $t:ty, $rhs:ty) => {
14        impl $trait_name<$rhs> for $t {
15            #[inline]
16            fn $method(&self, v: &$rhs) -> Self {
17                <$t>::$method(*self, *v)
18            }
19        }
20    };
21}
22
23/// Performs addition that wraps around on overflow.
24pub trait WrappingAdd: Sized + Add<Self, Output = Self> {
25    /// Wrapping (modular) addition. Computes `self + other`, wrapping around at the boundary of
26    /// the type.
27    fn wrapping_add(&self, v: &Self) -> Self;
28}
29
30impl WrappingAdd for u8 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self { <u8>::wrapping_add(*self, *v) }
}wrapping_impl!(WrappingAdd, wrapping_add, u8);
31impl WrappingAdd for u16 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <u16>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, u16);
32impl WrappingAdd for u32 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <u32>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, u32);
33impl WrappingAdd for u64 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <u64>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, u64);
34impl WrappingAdd for usize {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <usize>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, usize);
35impl WrappingAdd for u128 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <u128>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, u128);
36
37impl WrappingAdd for i8 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self { <i8>::wrapping_add(*self, *v) }
}wrapping_impl!(WrappingAdd, wrapping_add, i8);
38impl WrappingAdd for i16 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <i16>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, i16);
39impl WrappingAdd for i32 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <i32>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, i32);
40impl WrappingAdd for i64 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <i64>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, i64);
41impl WrappingAdd for isize {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <isize>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, isize);
42impl WrappingAdd for i128 {
    #[inline]
    fn wrapping_add(&self, v: &Self) -> Self {
        <i128>::wrapping_add(*self, *v)
    }
}wrapping_impl!(WrappingAdd, wrapping_add, i128);
43
44/// Performs subtraction that wraps around on overflow.
45pub trait WrappingSub: Sized + Sub<Self, Output = Self> {
46    /// Wrapping (modular) subtraction. Computes `self - other`, wrapping around at the boundary
47    /// of the type.
48    fn wrapping_sub(&self, v: &Self) -> Self;
49}
50
51impl WrappingSub for u8 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self { <u8>::wrapping_sub(*self, *v) }
}wrapping_impl!(WrappingSub, wrapping_sub, u8);
52impl WrappingSub for u16 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <u16>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, u16);
53impl WrappingSub for u32 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <u32>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, u32);
54impl WrappingSub for u64 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <u64>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, u64);
55impl WrappingSub for usize {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <usize>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, usize);
56impl WrappingSub for u128 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <u128>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, u128);
57
58impl WrappingSub for i8 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self { <i8>::wrapping_sub(*self, *v) }
}wrapping_impl!(WrappingSub, wrapping_sub, i8);
59impl WrappingSub for i16 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <i16>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, i16);
60impl WrappingSub for i32 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <i32>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, i32);
61impl WrappingSub for i64 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <i64>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, i64);
62impl WrappingSub for isize {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <isize>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, isize);
63impl WrappingSub for i128 {
    #[inline]
    fn wrapping_sub(&self, v: &Self) -> Self {
        <i128>::wrapping_sub(*self, *v)
    }
}wrapping_impl!(WrappingSub, wrapping_sub, i128);
64
65/// Performs multiplication that wraps around on overflow.
66pub trait WrappingMul: Sized + Mul<Self, Output = Self> {
67    /// Wrapping (modular) multiplication. Computes `self * other`, wrapping around at the boundary
68    /// of the type.
69    fn wrapping_mul(&self, v: &Self) -> Self;
70}
71
72impl WrappingMul for u8 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self { <u8>::wrapping_mul(*self, *v) }
}wrapping_impl!(WrappingMul, wrapping_mul, u8);
73impl WrappingMul for u16 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <u16>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, u16);
74impl WrappingMul for u32 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <u32>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, u32);
75impl WrappingMul for u64 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <u64>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, u64);
76impl WrappingMul for usize {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <usize>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, usize);
77impl WrappingMul for u128 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <u128>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, u128);
78
79impl WrappingMul for i8 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self { <i8>::wrapping_mul(*self, *v) }
}wrapping_impl!(WrappingMul, wrapping_mul, i8);
80impl WrappingMul for i16 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <i16>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, i16);
81impl WrappingMul for i32 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <i32>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, i32);
82impl WrappingMul for i64 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <i64>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, i64);
83impl WrappingMul for isize {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <isize>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, isize);
84impl WrappingMul for i128 {
    #[inline]
    fn wrapping_mul(&self, v: &Self) -> Self {
        <i128>::wrapping_mul(*self, *v)
    }
}wrapping_impl!(WrappingMul, wrapping_mul, i128);
85
86macro_rules! wrapping_unary_impl {
87    ($trait_name:ident, $method:ident, $t:ty) => {
88        impl $trait_name for $t {
89            #[inline]
90            fn $method(&self) -> $t {
91                <$t>::$method(*self)
92            }
93        }
94    };
95}
96
97/// Performs a negation that does not panic.
98pub trait WrappingNeg: Sized {
99    /// Wrapping (modular) negation. Computes `-self`,
100    /// wrapping around at the boundary of the type.
101    ///
102    /// Since unsigned types do not have negative equivalents
103    /// all applications of this function will wrap (except for `-0`).
104    /// For values smaller than the corresponding signed type's maximum
105    /// the result is the same as casting the corresponding signed value.
106    /// Any larger values are equivalent to `MAX + 1 - (val - MAX - 1)` where
107    /// `MAX` is the corresponding signed type's maximum.
108    ///
109    /// ```
110    /// use num_traits::WrappingNeg;
111    ///
112    /// assert_eq!(100i8.wrapping_neg(), -100);
113    /// assert_eq!((-100i8).wrapping_neg(), 100);
114    /// assert_eq!((-128i8).wrapping_neg(), -128); // wrapped!
115    /// ```
116    fn wrapping_neg(&self) -> Self;
117}
118
119impl WrappingNeg for u8 {
    #[inline]
    fn wrapping_neg(&self) -> u8 { <u8>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, u8);
120impl WrappingNeg for u16 {
    #[inline]
    fn wrapping_neg(&self) -> u16 { <u16>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, u16);
121impl WrappingNeg for u32 {
    #[inline]
    fn wrapping_neg(&self) -> u32 { <u32>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, u32);
122impl WrappingNeg for u64 {
    #[inline]
    fn wrapping_neg(&self) -> u64 { <u64>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, u64);
123impl WrappingNeg for usize {
    #[inline]
    fn wrapping_neg(&self) -> usize { <usize>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, usize);
124impl WrappingNeg for u128 {
    #[inline]
    fn wrapping_neg(&self) -> u128 { <u128>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, u128);
125impl WrappingNeg for i8 {
    #[inline]
    fn wrapping_neg(&self) -> i8 { <i8>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, i8);
126impl WrappingNeg for i16 {
    #[inline]
    fn wrapping_neg(&self) -> i16 { <i16>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, i16);
127impl WrappingNeg for i32 {
    #[inline]
    fn wrapping_neg(&self) -> i32 { <i32>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, i32);
128impl WrappingNeg for i64 {
    #[inline]
    fn wrapping_neg(&self) -> i64 { <i64>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, i64);
129impl WrappingNeg for isize {
    #[inline]
    fn wrapping_neg(&self) -> isize { <isize>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, isize);
130impl WrappingNeg for i128 {
    #[inline]
    fn wrapping_neg(&self) -> i128 { <i128>::wrapping_neg(*self) }
}wrapping_unary_impl!(WrappingNeg, wrapping_neg, i128);
131
132macro_rules! wrapping_shift_impl {
133    ($trait_name:ident, $method:ident, $t:ty) => {
134        impl $trait_name for $t {
135            #[inline]
136            fn $method(&self, rhs: u32) -> $t {
137                <$t>::$method(*self, rhs)
138            }
139        }
140    };
141}
142
143/// Performs a left shift that does not panic.
144pub trait WrappingShl: Sized + Shl<usize, Output = Self> {
145    /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
146    /// where `mask` removes any high order bits of `rhs` that would
147    /// cause the shift to exceed the bitwidth of the type.
148    ///
149    /// ```
150    /// use num_traits::WrappingShl;
151    ///
152    /// let x: u16 = 0x0001;
153    ///
154    /// assert_eq!(WrappingShl::wrapping_shl(&x, 0),  0x0001);
155    /// assert_eq!(WrappingShl::wrapping_shl(&x, 1),  0x0002);
156    /// assert_eq!(WrappingShl::wrapping_shl(&x, 15), 0x8000);
157    /// assert_eq!(WrappingShl::wrapping_shl(&x, 16), 0x0001);
158    /// ```
159    fn wrapping_shl(&self, rhs: u32) -> Self;
160}
161
162impl WrappingShl for u8 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> u8 { <u8>::wrapping_shl(*self, rhs) }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, u8);
163impl WrappingShl for u16 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> u16 {
        <u16>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, u16);
164impl WrappingShl for u32 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> u32 {
        <u32>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, u32);
165impl WrappingShl for u64 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> u64 {
        <u64>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, u64);
166impl WrappingShl for usize {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> usize {
        <usize>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, usize);
167impl WrappingShl for u128 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> u128 {
        <u128>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, u128);
168
169impl WrappingShl for i8 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> i8 { <i8>::wrapping_shl(*self, rhs) }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, i8);
170impl WrappingShl for i16 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> i16 {
        <i16>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, i16);
171impl WrappingShl for i32 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> i32 {
        <i32>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, i32);
172impl WrappingShl for i64 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> i64 {
        <i64>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, i64);
173impl WrappingShl for isize {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> isize {
        <isize>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, isize);
174impl WrappingShl for i128 {
    #[inline]
    fn wrapping_shl(&self, rhs: u32) -> i128 {
        <i128>::wrapping_shl(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShl, wrapping_shl, i128);
175
176/// Performs a right shift that does not panic.
177pub trait WrappingShr: Sized + Shr<usize, Output = Self> {
178    /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
179    /// where `mask` removes any high order bits of `rhs` that would
180    /// cause the shift to exceed the bitwidth of the type.
181    ///
182    /// ```
183    /// use num_traits::WrappingShr;
184    ///
185    /// let x: u16 = 0x8000;
186    ///
187    /// assert_eq!(WrappingShr::wrapping_shr(&x, 0),  0x8000);
188    /// assert_eq!(WrappingShr::wrapping_shr(&x, 1),  0x4000);
189    /// assert_eq!(WrappingShr::wrapping_shr(&x, 15), 0x0001);
190    /// assert_eq!(WrappingShr::wrapping_shr(&x, 16), 0x8000);
191    /// ```
192    fn wrapping_shr(&self, rhs: u32) -> Self;
193}
194
195impl WrappingShr for u8 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> u8 { <u8>::wrapping_shr(*self, rhs) }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, u8);
196impl WrappingShr for u16 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> u16 {
        <u16>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, u16);
197impl WrappingShr for u32 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> u32 {
        <u32>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, u32);
198impl WrappingShr for u64 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> u64 {
        <u64>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, u64);
199impl WrappingShr for usize {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> usize {
        <usize>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, usize);
200impl WrappingShr for u128 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> u128 {
        <u128>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, u128);
201
202impl WrappingShr for i8 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> i8 { <i8>::wrapping_shr(*self, rhs) }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, i8);
203impl WrappingShr for i16 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> i16 {
        <i16>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, i16);
204impl WrappingShr for i32 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> i32 {
        <i32>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, i32);
205impl WrappingShr for i64 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> i64 {
        <i64>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, i64);
206impl WrappingShr for isize {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> isize {
        <isize>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, isize);
207impl WrappingShr for i128 {
    #[inline]
    fn wrapping_shr(&self, rhs: u32) -> i128 {
        <i128>::wrapping_shr(*self, rhs)
    }
}wrapping_shift_impl!(WrappingShr, wrapping_shr, i128);
208
209// Well this is a bit funny, but all the more appropriate.
210impl<T: WrappingAdd> WrappingAdd for Wrapping<T>
211where
212    Wrapping<T>: Add<Output = Wrapping<T>>,
213{
214    fn wrapping_add(&self, v: &Self) -> Self {
215        Wrapping(self.0.wrapping_add(&v.0))
216    }
217}
218impl<T: WrappingSub> WrappingSub for Wrapping<T>
219where
220    Wrapping<T>: Sub<Output = Wrapping<T>>,
221{
222    fn wrapping_sub(&self, v: &Self) -> Self {
223        Wrapping(self.0.wrapping_sub(&v.0))
224    }
225}
226impl<T: WrappingMul> WrappingMul for Wrapping<T>
227where
228    Wrapping<T>: Mul<Output = Wrapping<T>>,
229{
230    fn wrapping_mul(&self, v: &Self) -> Self {
231        Wrapping(self.0.wrapping_mul(&v.0))
232    }
233}
234impl<T: WrappingNeg> WrappingNeg for Wrapping<T>
235where
236    Wrapping<T>: Neg<Output = Wrapping<T>>,
237{
238    fn wrapping_neg(&self) -> Self {
239        Wrapping(self.0.wrapping_neg())
240    }
241}
242impl<T: WrappingShl> WrappingShl for Wrapping<T>
243where
244    Wrapping<T>: Shl<usize, Output = Wrapping<T>>,
245{
246    fn wrapping_shl(&self, rhs: u32) -> Self {
247        Wrapping(self.0.wrapping_shl(rhs))
248    }
249}
250impl<T: WrappingShr> WrappingShr for Wrapping<T>
251where
252    Wrapping<T>: Shr<usize, Output = Wrapping<T>>,
253{
254    fn wrapping_shr(&self, rhs: u32) -> Self {
255        Wrapping(self.0.wrapping_shr(rhs))
256    }
257}
258
259#[test]
260fn test_wrapping_traits() {
261    fn wrapping_add<T: WrappingAdd>(a: T, b: T) -> T {
262        a.wrapping_add(&b)
263    }
264    fn wrapping_sub<T: WrappingSub>(a: T, b: T) -> T {
265        a.wrapping_sub(&b)
266    }
267    fn wrapping_mul<T: WrappingMul>(a: T, b: T) -> T {
268        a.wrapping_mul(&b)
269    }
270    fn wrapping_neg<T: WrappingNeg>(a: T) -> T {
271        a.wrapping_neg()
272    }
273    fn wrapping_shl<T: WrappingShl>(a: T, b: u32) -> T {
274        a.wrapping_shl(b)
275    }
276    fn wrapping_shr<T: WrappingShr>(a: T, b: u32) -> T {
277        a.wrapping_shr(b)
278    }
279    assert_eq!(wrapping_add(255, 1), 0u8);
280    assert_eq!(wrapping_sub(0, 1), 255u8);
281    assert_eq!(wrapping_mul(255, 2), 254u8);
282    assert_eq!(wrapping_neg(255), 1u8);
283    assert_eq!(wrapping_shl(255, 8), 255u8);
284    assert_eq!(wrapping_shr(255, 8), 255u8);
285    assert_eq!(wrapping_add(255, 1), (Wrapping(255u8) + Wrapping(1u8)).0);
286    assert_eq!(wrapping_sub(0, 1), (Wrapping(0u8) - Wrapping(1u8)).0);
287    assert_eq!(wrapping_mul(255, 2), (Wrapping(255u8) * Wrapping(2u8)).0);
288    assert_eq!(wrapping_neg(255), (-Wrapping(255u8)).0);
289    assert_eq!(wrapping_shl(255, 8), (Wrapping(255u8) << 8).0);
290    assert_eq!(wrapping_shr(255, 8), (Wrapping(255u8) >> 8).0);
291}
292
293#[test]
294fn wrapping_is_wrappingadd() {
295    fn require_wrappingadd<T: WrappingAdd>(_: &T) {}
296    require_wrappingadd(&Wrapping(42));
297}
298
299#[test]
300fn wrapping_is_wrappingsub() {
301    fn require_wrappingsub<T: WrappingSub>(_: &T) {}
302    require_wrappingsub(&Wrapping(42));
303}
304
305#[test]
306fn wrapping_is_wrappingmul() {
307    fn require_wrappingmul<T: WrappingMul>(_: &T) {}
308    require_wrappingmul(&Wrapping(42));
309}
310
311#[test]
312fn wrapping_is_wrappingneg() {
313    fn require_wrappingneg<T: WrappingNeg>(_: &T) {}
314    require_wrappingneg(&Wrapping(42));
315}
316
317#[test]
318fn wrapping_is_wrappingshl() {
319    fn require_wrappingshl<T: WrappingShl>(_: &T) {}
320    require_wrappingshl(&Wrapping(42));
321}
322
323#[test]
324fn wrapping_is_wrappingshr() {
325    fn require_wrappingshr<T: WrappingShr>(_: &T) {}
326    require_wrappingshr(&Wrapping(42));
327}
num_traits/ops/wrapping.rs

num_traits/ops/
wrapping.rs
