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

num_traits/ops/
wrapping.rs
