traiter 4.0.0

Traits collection.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

use super::types::TieBreaking;

pub trait Round {
    type Output;

    /// Returns rounding of a number.
    ///
    #[cfg_attr(
        feature = "std",
        doc = r##"
```
// floating point numbers
use traiter::numbers::{Round, TieBreaking};
assert_eq!(Round::round(-0.5_f32, TieBreaking::AwayFromZero), -1.0_f32);
assert_eq!(Round::round(-0.5_f32, TieBreaking::ToEven), 0.0_f32);
assert_eq!(Round::round(-0.5_f32, TieBreaking::ToOdd), -1.0_f32);
assert_eq!(Round::round(-0.5_f32, TieBreaking::TowardZero), 0.0_f32);
```
"##
    )]
    fn round(self, tie_breaking: TieBreaking) -> Self::Output;
}

macro_rules! float_round_impl {
    ($($float:ty)*) => ($(
        impl Round for $float {
            type Output = Self;

            #[inline(always)]
            fn round(self, tie_breaking: TieBreaking) -> Self::Output {
                match tie_breaking {
                    TieBreaking::AwayFromZero => <$float>::round(self),
                    TieBreaking::ToEven => {
                        if self.ceil() - self == (0.5 as $float) {
                            2.0 * <$float>::round(self / 2.0)
                        } else {
                            <$float>::round(self)
                        }
                    }
                    TieBreaking::ToOdd => {
                        if self.ceil() - self == (0.5 as $float) {
                            2.0 * (self / 2.0).floor() + 1.0
                        } else {
                            <$float>::round(self)
                        }
                    }
                    TieBreaking::TowardZero => {
                        if self.ceil() - self == (0.5 as $float) {
                            self.trunc()
                        } else {
                            <$float>::round(self)
                        }
                    }
                }
            }
        }
    )*)
}

#[cfg(feature = "std")]
float_round_impl!(f32 f64);