traiter/numbers/
signed.rs

1use super::types::Sign;
2use super::zeroable::Zeroable;
3use core::cmp::Ordering;
4
5pub trait Signed: Zeroable {
6    /// Checks if a number is negative.
7    /// ```
8    /// use traiter::numbers::Signed;
9    /// // signed integers
10    /// assert!(Signed::is_negative(-1i8));
11    /// assert!(!Signed::is_negative(0i8));
12    /// assert!(!Signed::is_negative(1i8));
13    /// ```
14    fn is_negative(self) -> bool;
15
16    /// Checks if a number is positive.
17    /// ```
18    /// use traiter::numbers::Signed;
19    /// // signed integers
20    /// assert!(!Signed::is_positive(-1i8));
21    /// assert!(!Signed::is_positive(0i8));
22    /// assert!(Signed::is_positive(1i8));
23    /// ```
24    fn is_positive(self) -> bool;
25
26    /// Returns sign of a number.
27    /// ```
28    /// use traiter::numbers::{Signed, Sign};
29    /// // signed integers
30    /// assert_eq!(Signed::sign(-1i8), Sign::Negative);
31    /// assert_eq!(Signed::sign(0i8), Sign::Zero);
32    /// assert_eq!(Signed::sign(1i8), Sign::Positive);
33    /// ```
34    fn sign(self) -> Sign;
35}
36
37macro_rules! signed_integer_impl {
38    ($($integer:ty)*) => ($(
39        impl Signed for $integer {
40            #[inline(always)]
41            fn is_negative(self) -> bool {
42                <$integer>::is_negative(self)
43            }
44
45            #[inline(always)]
46            fn is_positive(self) -> bool {
47                <$integer>::is_positive(self)
48            }
49
50            #[inline(always)]
51            fn sign(self) -> Sign {
52                match self.cmp(&(0 as $integer)) {
53                    Ordering::Equal => Sign::Zero,
54                    Ordering::Greater => Sign::Positive,
55                    Ordering::Less => Sign::Negative,
56                }
57            }
58        }
59
60        impl Signed for &$integer {
61            #[inline(always)]
62            fn is_negative(self) -> bool {
63                <$integer>::is_negative(*self)
64            }
65
66            #[inline(always)]
67            fn is_positive(self) -> bool {
68                <$integer>::is_positive(*self)
69            }
70
71            #[inline(always)]
72            fn sign(self) -> Sign {
73                match self.cmp(&(0 as $integer)) {
74                    Ordering::Equal => Sign::Zero,
75                    Ordering::Greater => Sign::Positive,
76                    Ordering::Less => Sign::Negative,
77                }
78            }
79        }
80    )*)
81}
82
83signed_integer_impl!(i8 i16 i32 i64 i128 isize);