2018-01-31 23:42:55 +00:00
|
|
|
use core::ops::{Add, Sub, Mul};
|
|
|
|
use core::num::Wrapping;
|
2017-01-22 08:45:35 +00:00
|
|
|
|
|
|
|
macro_rules! wrapping_impl {
|
|
|
|
($trait_name:ident, $method:ident, $t:ty) => {
|
|
|
|
impl $trait_name for $t {
|
|
|
|
#[inline]
|
|
|
|
fn $method(&self, v: &Self) -> Self {
|
|
|
|
<$t>::$method(*self, *v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
($trait_name:ident, $method:ident, $t:ty, $rhs:ty) => {
|
|
|
|
impl $trait_name<$rhs> for $t {
|
|
|
|
#[inline]
|
|
|
|
fn $method(&self, v: &$rhs) -> Self {
|
|
|
|
<$t>::$method(*self, *v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-26 20:12:27 +00:00
|
|
|
/// Performs addition that wraps around on overflow.
|
2017-01-22 08:45:35 +00:00
|
|
|
pub trait WrappingAdd: Sized + Add<Self, Output=Self> {
|
|
|
|
/// Wrapping (modular) addition. Computes `self + other`, wrapping around at the boundary of
|
|
|
|
/// the type.
|
|
|
|
fn wrapping_add(&self, v: &Self) -> Self;
|
|
|
|
}
|
|
|
|
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, u8);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, u16);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, u32);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, u64);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, usize);
|
2018-05-11 22:50:48 +00:00
|
|
|
#[cfg(has_i128)]
|
2018-04-09 09:11:05 +00:00
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, u128);
|
2017-01-22 08:45:35 +00:00
|
|
|
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, i8);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, i16);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, i32);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, i64);
|
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, isize);
|
2018-05-11 22:50:48 +00:00
|
|
|
#[cfg(has_i128)]
|
2018-04-09 09:11:05 +00:00
|
|
|
wrapping_impl!(WrappingAdd, wrapping_add, i128);
|
2017-01-22 08:45:35 +00:00
|
|
|
|
2017-01-26 20:12:27 +00:00
|
|
|
/// Performs subtraction that wraps around on overflow.
|
2017-01-22 08:45:35 +00:00
|
|
|
pub trait WrappingSub: Sized + Sub<Self, Output=Self> {
|
|
|
|
/// Wrapping (modular) subtraction. Computes `self - other`, wrapping around at the boundary
|
|
|
|
/// of the type.
|
|
|
|
fn wrapping_sub(&self, v: &Self) -> Self;
|
|
|
|
}
|
|
|
|
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, u8);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, u16);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, u32);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, u64);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, usize);
|
2018-05-11 22:50:48 +00:00
|
|
|
#[cfg(has_i128)]
|
2018-04-09 09:11:05 +00:00
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, u128);
|
2017-01-22 08:45:35 +00:00
|
|
|
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, i8);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, i16);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, i32);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, i64);
|
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, isize);
|
2018-05-11 22:50:48 +00:00
|
|
|
#[cfg(has_i128)]
|
2018-04-09 09:11:05 +00:00
|
|
|
wrapping_impl!(WrappingSub, wrapping_sub, i128);
|
2017-01-22 08:45:35 +00:00
|
|
|
|
2017-01-26 20:12:27 +00:00
|
|
|
/// Performs multiplication that wraps around on overflow.
|
2017-01-22 08:45:35 +00:00
|
|
|
pub trait WrappingMul: Sized + Mul<Self, Output=Self> {
|
|
|
|
/// Wrapping (modular) multiplication. Computes `self * other`, wrapping around at the boundary
|
|
|
|
/// of the type.
|
|
|
|
fn wrapping_mul(&self, v: &Self) -> Self;
|
|
|
|
}
|
|
|
|
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, u8);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, u16);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, u32);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, u64);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, usize);
|
2018-05-11 22:50:48 +00:00
|
|
|
#[cfg(has_i128)]
|
2018-04-09 09:11:05 +00:00
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, u128);
|
2017-01-22 08:45:35 +00:00
|
|
|
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, i8);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, i16);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, i32);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, i64);
|
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, isize);
|
2018-05-11 22:50:48 +00:00
|
|
|
#[cfg(has_i128)]
|
2018-04-09 09:11:05 +00:00
|
|
|
wrapping_impl!(WrappingMul, wrapping_mul, i128);
|
2017-02-04 09:42:12 +00:00
|
|
|
|
2017-04-29 06:29:02 +00:00
|
|
|
// Well this is a bit funny, but all the more appropriate.
|
|
|
|
impl<T: WrappingAdd> WrappingAdd for Wrapping<T> where Wrapping<T>: Add<Output = Wrapping<T>> {
|
|
|
|
fn wrapping_add(&self, v: &Self) -> Self {
|
|
|
|
Wrapping(self.0.wrapping_add(&v.0))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl<T: WrappingSub> WrappingSub for Wrapping<T> where Wrapping<T>: Sub<Output = Wrapping<T>> {
|
|
|
|
fn wrapping_sub(&self, v: &Self) -> Self {
|
|
|
|
Wrapping(self.0.wrapping_sub(&v.0))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
impl<T: WrappingMul> WrappingMul for Wrapping<T> where Wrapping<T>: Mul<Output = Wrapping<T>> {
|
|
|
|
fn wrapping_mul(&self, v: &Self) -> Self {
|
|
|
|
Wrapping(self.0.wrapping_mul(&v.0))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-04 09:42:12 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_wrapping_traits() {
|
|
|
|
fn wrapping_add<T: WrappingAdd>(a: T, b: T) -> T { a.wrapping_add(&b) }
|
|
|
|
fn wrapping_sub<T: WrappingSub>(a: T, b: T) -> T { a.wrapping_sub(&b) }
|
|
|
|
fn wrapping_mul<T: WrappingMul>(a: T, b: T) -> T { a.wrapping_mul(&b) }
|
|
|
|
assert_eq!(wrapping_add(255, 1), 0u8);
|
|
|
|
assert_eq!(wrapping_sub(0, 1), 255u8);
|
|
|
|
assert_eq!(wrapping_mul(255, 2), 254u8);
|
2017-04-30 08:17:06 +00:00
|
|
|
assert_eq!(wrapping_add(255, 1), (Wrapping(255u8) + Wrapping(1u8)).0);
|
|
|
|
assert_eq!(wrapping_sub(0, 1), (Wrapping(0u8) - Wrapping(1u8)).0);
|
|
|
|
assert_eq!(wrapping_mul(255, 2), (Wrapping(255u8) * Wrapping(2u8)).0);
|
2017-02-04 09:42:12 +00:00
|
|
|
}
|
2017-05-01 11:42:30 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn wrapping_is_wrappingadd() {
|
|
|
|
fn require_wrappingadd<T: WrappingAdd>(_: &T) {}
|
|
|
|
require_wrappingadd(&Wrapping(42));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn wrapping_is_wrappingsub() {
|
|
|
|
fn require_wrappingsub<T: WrappingSub>(_: &T) {}
|
|
|
|
require_wrappingsub(&Wrapping(42));
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn wrapping_is_wrappingmul() {
|
|
|
|
fn require_wrappingmul<T: WrappingMul>(_: &T) {}
|
|
|
|
require_wrappingmul(&Wrapping(42));
|
|
|
|
}
|