Skip to content

Commit 50afb16

Browse files
SparrowLiicuviper
SparrowLii
authored and
cuviper
committed
fixes codes structure etc.
1 parent ee53faf commit 50afb16

File tree

2 files changed

+84
-119
lines changed

2 files changed

+84
-119
lines changed

‎src/lib.rs‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,14 +33,15 @@ pub use bounds::Bounded;
3333
#[cfg(any(feature = "std", feature = "libm"))]
3434
pub use float::Float;
3535
pub use float::FloatConst;
36+
pub use float::FloatCore;
3637
// pub use real::{FloatCore, Real}; // NOTE: Don't do this, it breaks `use num_traits::*;`.
3738
pub use cast::{cast, AsPrimitive, FromPrimitive, NumCast, ToPrimitive};
3839
pub use identities::{one, zero, One, Zero};
3940
pub use int::PrimInt;
4041
pub use ops::checked::{
4142
CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedRem, CheckedShl, CheckedShr, CheckedSub,
4243
};
43-
pub use ops::euclid::{CheckedDivEuclid, CheckedRemEuclid, DivEuclid, RemEuclid};
44+
pub use ops::euclid::{CheckedEuclid, Euclid};
4445
pub use ops::inv::Inv;
4546
pub use ops::mul_add::{MulAdd, MulAddAssign};
4647
pub use ops::saturating::{Saturating, SaturatingAdd, SaturatingMul, SaturatingSub};
@@ -49,6 +50,7 @@ pub use ops::wrapping::{
4950
};
5051
pub use pow::{checked_pow, pow, Pow};
5152
pub use sign::{abs, abs_sub, signum, Signed, Unsigned};
53+
5254
#[macro_use]
5355
mod macros;
5456

‎src/ops/euclid.rs‎

Lines changed: 81 additions & 118 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
use core::ops::{Div, Rem};
2-
pub trait DivEuclid: Sized + Div<Self, Output = Self> {
2+
3+
pub trait Euclid: Sized + Div<Self, Output = Self> + Rem<Self, Output = Self> {
34
/// Calculates Euclidean division, the matching method for `rem_euclid`.
45
///
56
/// This computes the integer `n` such that
@@ -10,18 +11,17 @@ pub trait DivEuclid: Sized + Div<Self, Output = Self> {
1011
/// # Examples
1112
///
1213
/// ```
13-
/// use num_traits::DivEuclid;
14+
/// use num_traits::Euclid;
1415
///
1516
/// let a: i32 = 7;
1617
/// let b: i32 = 4;
17-
/// assert_eq!(DivEuclid::div_euclid(a,b), 1); // 7 > 4 * 1
18-
/// assert_eq!(DivEuclid::div_euclid(-a,b), -2); // -7 >= 4 * -2
19-
/// assert_eq!(DivEuclid::div_euclid(a,-b), -1); // 7 >= -4 * -1
20-
/// assert_eq!(DivEuclid::div_euclid(-a,-b), 2); // -7 >= -4 * 2
18+
/// assert_eq!(Euclid::div_euclid(a, b), 1); // 7 > 4 * 1
19+
/// assert_eq!(Euclid::div_euclid(-a, b), -2); // -7 >= 4 * -2
20+
/// assert_eq!(Euclid::div_euclid(a, -b), -1); // 7 >= -4 * -1
21+
/// assert_eq!(Euclid::div_euclid(-a, -b), 2); // -7 >= -4 * 2
2122
/// ```
2223
fn div_euclid(self, v: Self) -> Self;
23-
}
24-
pub trait RemEuclid: Sized + Rem<Self, Output = Self> {
24+
2525
/// Calculates the least nonnegative remainder of `self (mod v)`.
2626
///
2727
/// In particular, the return value `r` satisfies `0.0 <= r < v.abs()` in
@@ -36,20 +36,20 @@ pub trait RemEuclid: Sized + Rem<Self, Output = Self> {
3636
/// # Examples
3737
///
3838
/// ```
39-
/// use num_traits::RemEuclid;
39+
/// use num_traits::Euclid;
4040
///
4141
/// let a: i32 = 7;
4242
/// let b: i32 = 4;
43-
/// assert_eq!(RemEuclid::rem_euclid(a,b), 3);
44-
/// assert_eq!(RemEuclid::rem_euclid(-a,b), 1);
45-
/// assert_eq!(RemEuclid::rem_euclid(a,-b), 3);
46-
/// assert_eq!(RemEuclid::rem_euclid(-a,-b), 1);
43+
/// assert_eq!(Euclid::rem_euclid(a, b), 3);
44+
/// assert_eq!(Euclid::rem_euclid(-a, b), 1);
45+
/// assert_eq!(Euclid::rem_euclid(a, -b), 3);
46+
/// assert_eq!(Euclid::rem_euclid(-a, -b), 1);
4747
/// ```
4848
fn rem_euclid(self, v: Self) -> Self;
4949
}
50-
macro_rules! div_euclid_int_impl {
51-
($trait_name:ident for $($t:ty)*) => {$(
52-
impl $trait_name for $t {
50+
macro_rules! euclid_int_impl {
51+
($($t:ty)*) => {$(
52+
impl Euclid for $t {
5353
#[inline]
5454
fn div_euclid(self, v: $t) -> Self {
5555
let q = self / v;
@@ -58,22 +58,7 @@ macro_rules! div_euclid_int_impl {
5858
}
5959
q
6060
}
61-
}
62-
)*}
63-
}
64-
macro_rules! div_euclid_uint_impl {
65-
($trait_name:ident for $($t:ty)*) => {$(
66-
impl $trait_name for $t {
67-
#[inline]
68-
fn div_euclid(self, v: $t) -> Self {
69-
self / v
70-
}
71-
}
72-
)*}
73-
}
74-
macro_rules! rem_euclid_int_impl {
75-
($trait_name:ident for $($t:ty)*) => {$(
76-
impl $trait_name for $t {
61+
7762
#[inline]
7863
fn rem_euclid(self, v: $t) -> Self {
7964
let r = self % v;
@@ -90,152 +75,131 @@ macro_rules! rem_euclid_int_impl {
9075
}
9176
)*}
9277
}
93-
macro_rules! rem_euclid_uint_impl {
94-
($trait_name:ident for $($t:ty)*) => {$(
95-
impl $trait_name for $t {
78+
macro_rules! euclid_uint_impl {
79+
($($t:ty)*) => {$(
80+
impl Euclid for $t {
81+
#[inline]
82+
fn div_euclid(self, v: $t) -> Self {
83+
self / v
84+
}
85+
9686
#[inline]
9787
fn rem_euclid(self, v: $t) -> Self {
9888
self % v
9989
}
10090
}
10191
)*}
10292
}
103-
div_euclid_int_impl!(DivEuclid for i8 i16 i32 i64);
104-
div_euclid_uint_impl!(DivEuclid for isize usize u8 u16 u32 u64);
105-
rem_euclid_int_impl!(RemEuclid for i8 i16 i32 i64);
106-
rem_euclid_uint_impl!(RemEuclid for isize usize u8 u16 u32 u64);
107-
#[cfg(has_i128)]
108-
div_euclid_int_impl!(DivEuclid for i128);
93+
euclid_int_impl!(isize i8 i16 i32 i64);
94+
euclid_uint_impl!(usize u8 u16 u32 u64);
10995
#[cfg(has_i128)]
110-
div_euclid_uint_impl!(DivEuclid for u128);
96+
euclid_int_impl!(i128);
11197
#[cfg(has_i128)]
112-
rem_euclid_int_impl!(RemEuclid for i128);
113-
#[cfg(has_i128)]
114-
rem_euclid_uint_impl!(RemEuclid for u128);
98+
euclid_uint_impl!(u128);
11599

116-
#[cfg(any(feature = "std", feature = "libm"))]
117-
impl DivEuclid for f32 {
100+
impl Euclid for f32 {
101+
#[inline]
118102
fn div_euclid(self, v: f32) -> f32 {
119-
let q = <f32 as ::Float>::trunc(self / v);
103+
let q = <f32 as ::FloatCore>::trunc(self / v);
120104
if self % v < 0.0 {
121105
return if v > 0.0 { q - 1.0 } else { q + 1.0 };
122106
}
123107
q
124108
}
125-
}
126109

127-
#[cfg(any(feature = "std", feature = "libm"))]
128-
impl RemEuclid for f32 {
110+
#[inline]
129111
fn rem_euclid(self, v: f32) -> f32 {
130112
let r = self % v;
131113
if r < 0.0 {
132-
r + <f32 as ::Float>::abs(v)
114+
r + <f32 as ::FloatCore>::abs(v)
133115
} else {
134116
r
135117
}
136118
}
137119
}
138120

139-
#[cfg(any(feature = "std", feature = "libm"))]
140-
impl DivEuclid for f64 {
121+
impl Euclid for f64 {
122+
#[inline]
141123
fn div_euclid(self, v: f64) -> f64 {
142-
let q = <f64 as ::Float>::trunc(self / v);
124+
let q = <f64 as ::FloatCore>::trunc(self / v);
143125
if self % v < 0.0 {
144126
return if v > 0.0 { q - 1.0 } else { q + 1.0 };
145127
}
146128
q
147129
}
148-
}
149-
#[cfg(any(feature = "std", feature = "libm"))]
150-
impl RemEuclid for f64 {
130+
131+
#[inline]
151132
fn rem_euclid(self, v: f64) -> f64 {
152133
let r = self % v;
153134
if r < 0.0 {
154-
r + <f64 as ::Float>::abs(v)
135+
r + <f64 as ::FloatCore>::abs(v)
155136
} else {
156137
r
157138
}
158139
}
159140
}
160141

161-
pub trait CheckedDivEuclid: DivEuclid {
142+
pub trait CheckedEuclid: Euclid {
162143
/// Performs euclid division that returns `None` instead of panicking on division by zero
163144
/// and instead of wrapping around on underflow and overflow.
164145
fn checked_div_euclid(self, v: Self) -> Option<Self>;
165-
}
166-
pub trait CheckedRemEuclid: RemEuclid {
146+
167147
/// Finds the euclid remainder of dividing two numbers, checking for underflow, overflow and
168148
/// division by zero. If any of that happens, `None` is returned.
169149
fn checked_rem_euclid(self, v: Self) -> Option<Self>;
170150
}
171-
macro_rules! checked_div_euclid_int_impl {
172-
($trait_name:ident for $($t:ty)*) => {$(
173-
impl $trait_name for $t {
151+
macro_rules! checked_euclid_int_impl {
152+
($($t:ty)*) => {$(
153+
impl CheckedEuclid for $t {
174154
#[inline]
175155
fn checked_div_euclid(self, v: $t) -> Option<$t> {
176156
if v == 0 || (self == Self::min_value() && v == -1) {
177157
None
178158
} else {
179-
Some(DivEuclid::div_euclid(self,v))
159+
Some(Euclid::div_euclid(self, v))
180160
}
181161
}
182-
}
183-
)*}
184-
}
185-
macro_rules! checked_div_euclid_uint_impl {
186-
($trait_name:ident for $($t:ty)*) => {$(
187-
impl $trait_name for $t {
162+
188163
#[inline]
189-
fn checked_div_euclid(self, v: $t) -> Option<$t> {
190-
if v == 0{
164+
fn checked_rem_euclid(self, v: $t) -> Option<$t> {
165+
if v == 0 || (self == Self::min_value() && v == -1) {
191166
None
192167
} else {
193-
Some(DivEuclid::div_euclid(self,v))
168+
Some(Euclid::rem_euclid(self, v))
194169
}
195170
}
196171
}
197172
)*}
198173
}
199-
macro_rules! checked_rem_euclid_int_impl {
200-
($trait_name:ident for $($t:ty)*) => {$(
201-
impl $trait_name for $t {
174+
macro_rules! checked_euclid_uint_impl {
175+
($($t:ty)*) => {$(
176+
impl CheckedEuclid for $t {
202177
#[inline]
203-
fn checked_rem_euclid(self, v: $t) -> Option<$t> {
204-
if v == 0 || (self == Self::min_value() && v == -1) {
178+
fn checked_div_euclid(self, v: $t) -> Option<$t> {
179+
if v == 0{
205180
None
206181
} else {
207-
Some(RemEuclid::rem_euclid(self,v))
182+
Some(Euclid::div_euclid(self, v))
208183
}
209184
}
210-
}
211-
)*}
212-
}
213-
macro_rules! checked_rem_euclid_uint_impl {
214-
($trait_name:ident for $($t:ty)*) => {$(
215-
impl $trait_name for $t {
185+
216186
#[inline]
217187
fn checked_rem_euclid(self, v: $t) -> Option<$t> {
218188
if v == 0{
219189
None
220190
} else {
221-
Some(RemEuclid::rem_euclid(self,v))
191+
Some(Euclid::rem_euclid(self, v))
222192
}
223193
}
224194
}
225195
)*}
226196
}
227-
checked_div_euclid_int_impl!(CheckedDivEuclid for i8 i16 i32 i64);
228-
checked_div_euclid_uint_impl!(CheckedDivEuclid for isize usize u8 u16 u32 u64);
229-
checked_rem_euclid_int_impl!(CheckedRemEuclid for i8 i16 i32 i64);
230-
checked_rem_euclid_uint_impl!(CheckedRemEuclid for isize usize u8 u16 u32 u64);
231-
#[cfg(has_i128)]
232-
checked_div_euclid_int_impl!(CheckedDivEuclid for i128);
233-
#[cfg(has_i128)]
234-
checked_div_euclid_uint_impl!(CheckedDivEuclid for u128);
197+
checked_euclid_int_impl!(isize i8 i16 i32 i64);
198+
checked_euclid_uint_impl!(usize u8 u16 u32 u64);
235199
#[cfg(has_i128)]
236-
checked_rem_euclid_int_impl!(CheckedRemEuclid for i128);
200+
checked_euclid_int_impl!(i128);
237201
#[cfg(has_i128)]
238-
checked_rem_euclid_uint_impl!(CheckedRemEuclid for u128);
202+
checked_euclid_uint_impl!(u128);
239203

240204
#[cfg(test)]
241205
mod tests {
@@ -249,8 +213,8 @@ mod tests {
249213
{
250214
let x: $t = 10;
251215
let y: $t = 3;
252-
assert_eq!(DivEuclid::div_euclid(x,y),3);
253-
assert_eq!(RemEuclid::rem_euclid(x,y),1);
216+
assert_eq!(Euclid::div_euclid(x, y),3);
217+
assert_eq!(Euclid::rem_euclid(x, y),1);
254218
}
255219
)+
256220
};
@@ -267,13 +231,13 @@ mod tests {
267231
{
268232
let x: $t = 10;
269233
let y: $t = -3;
270-
assert_eq!(DivEuclid::div_euclid(x,y),-3);
271-
assert_eq!(DivEuclid::div_euclid(-x,y),4);
272-
assert_eq!(RemEuclid::rem_euclid(x,y),1);
273-
assert_eq!(RemEuclid::rem_euclid(-x,y),2);
234+
assert_eq!(Euclid::div_euclid(x, y),-3);
235+
assert_eq!(Euclid::div_euclid(-x, y),4);
236+
assert_eq!(Euclid::rem_euclid(x, y),1);
237+
assert_eq!(Euclid::rem_euclid(-x, y),2);
274238
let x: $t = $t::min_value()+1;
275239
let y: $t = -1;
276-
assert_eq!(DivEuclid::div_euclid(x,y),$t::max_value());
240+
assert_eq!(Euclid::div_euclid(x, y),$t::max_value());
277241
}
278242
)+
279243
};
@@ -283,22 +247,21 @@ mod tests {
283247
}
284248

285249
#[test]
286-
#[cfg(any(feature = "std", feature = "libm"))]
287250
fn euclid_float() {
288251
macro_rules! test_euclid {
289252
($($t:ident)+) => {
290253
$(
291254
{
292255
let x: $t = 12.1;
293256
let y: $t = 3.2;
294-
assert!(DivEuclid::div_euclid(x,y)*y+RemEuclid::rem_euclid(x,y)-x
295-
<=46.4 * <$t as ::Float>::epsilon());
296-
assert!(DivEuclid::div_euclid(x,-y)*-y+RemEuclid::rem_euclid(x,-y)-x
297-
<= 46.4 * <$t as ::Float>::epsilon());
298-
assert!(DivEuclid::div_euclid(-x,y)*y+RemEuclid::rem_euclid(-x,y)-(-x)
299-
<= 46.4 * <$t as ::Float>::epsilon());
300-
assert!(DivEuclid::div_euclid(-x,-y)*-y+RemEuclid::rem_euclid(-x,-y)-(-x)
301-
<= 46.4 * <$t as ::Float>::epsilon());
257+
assert!(Euclid::div_euclid(x, y)*y+Euclid::rem_euclid(x, y)-x
258+
<=46.4 * <$t as ::FloatCore>::epsilon());
259+
assert!(Euclid::div_euclid(x, -y)*-y+Euclid::rem_euclid(x, -y)-x
260+
<= 46.4 * <$t as ::FloatCore>::epsilon());
261+
assert!(Euclid::div_euclid(-x, y)*y+Euclid::rem_euclid(-x, y)-(-x)
262+
<= 46.4 * <$t as ::FloatCore>::epsilon());
263+
assert!(Euclid::div_euclid(-x, -y)*-y+Euclid::rem_euclid(-x, -y)-(-x)
264+
<= 46.4 * <$t as ::FloatCore>::epsilon());
302265
}
303266
)+
304267
};
@@ -313,10 +276,10 @@ mod tests {
313276
($($t:ident)+) => {
314277
$(
315278
{
316-
assert_eq!(CheckedDivEuclid::checked_div_euclid($t::min_value(),-1),None);
317-
assert_eq!(CheckedRemEuclid::checked_rem_euclid($t::min_value(),-1),None);
318-
assert_eq!(CheckedDivEuclid::checked_div_euclid(1,0),None);
319-
assert_eq!(CheckedRemEuclid::checked_rem_euclid(1,0),None);
279+
assert_eq!(CheckedEuclid::checked_div_euclid($t::min_value(), -1),None);
280+
assert_eq!(CheckedEuclid::checked_rem_euclid($t::min_value(), -1),None);
281+
assert_eq!(CheckedEuclid::checked_div_euclid(1, 0),None);
282+
assert_eq!(CheckedEuclid::checked_rem_euclid(1, 0),None);
320283
}
321284
)+
322285
};

0 commit comments

Comments
 (0)