newnum 0.13.1

Deprecated: General-purpose number traits
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

/// Trait for `trunc_sqrt` and `trunc_cbrt` methods, which compute the truncated square root and cube root of a number.
///
/// For non-numbers types (number-containers like `Vec2`) the logic of `sqrt` / `cbrt` should follow the logic of `Mul`.
/// For example, if `<Vec2 as Mul>` multiplies each component seperately, <Vec2 as TruncRoot> should also `sqrt` each component seperately.
pub trait TruncRoot {
    fn trunc_sqrt(self) -> Self;
    fn trunc_cbrt(self) -> Self;
}

/// Trait for `sqrt` and `cbrt` methods, which compute the square root and cube root of a number.
///
/// For non-numbers types (number-containers like `Vec2`) the logic of `sqrt` / `cbrt` should follow the logic of `Mul`.
/// For example, if `<Vec2 as Mul>` multiplies each component seperately, <Vec2 as Root> should also `sqrt` each component seperately.
pub trait Root: TruncRoot {
    fn sqrt(self) -> Self;
    fn cbrt(self) -> Self;
}

macro_rules! int_impl {
    ($type:ident) => {
        impl TruncRoot for $type {
            fn trunc_sqrt(self) -> Self {
                const FLOAT_CONVERT_LIMIT: Option<$type> = (1 as $type).checked_shl(52);

                if let Some(convert_lim) = FLOAT_CONVERT_LIMIT {
                    if self < convert_lim {
                        (self as f64).sqrt() as Self
                    } else {
                        let max_sqrt = (0 as $type..)
                            .filter(|x| x.checked_mul(*x).is_some())
                            .last()
                            .unwrap();

                        let mut low = 1;
                        let mut high = (self / 2).min(max_sqrt);

                        while low <= high {
                            let mid = (low + high) / 2;
                            let mid_squared = mid * mid;
                            if mid_squared == self {
                                return mid;
                            } else if mid_squared < self {
                                low = mid + 1;
                            } else {
                                high = mid - 1;
                            }
                        }

                        high
                    }
                } else {
                    (self as f64).sqrt() as Self
                }
            }

            fn trunc_cbrt(self) -> Self {
                const FLOAT_CONVERT_LIMIT: Option<$type> = (1 as $type).checked_shl(52);

                if let Some(convert_lim) = FLOAT_CONVERT_LIMIT {
                    if self < convert_lim {
                        (self as f64).cbrt() as Self
                    } else {
                        let max_cbrt = (0 as $type..)
                            .filter(|x| {
                                x.checked_mul(*x)
                                    .map_or(None, |x| x.checked_mul(x))
                                    .is_some()
                            })
                            .last()
                            .unwrap();

                        let mut low = 1;
                        let mut high = (self / 2).min(max_cbrt);

                        while low <= high {
                            let mid = (low + high) / 2;
                            let mid_cubed = mid * mid * mid;
                            if mid_cubed == self {
                                return mid;
                            } else if mid_cubed < self {
                                low = mid + 1;
                            } else {
                                high = mid - 1;
                            }
                        }

                        high
                    }
                } else {
                    (self as f64).cbrt() as Self
                }
            }
        }
    };
}
int_impl!(u8);
int_impl!(u16);
int_impl!(u32);
int_impl!(u64);
int_impl!(u128);
int_impl!(usize);
int_impl!(i8);
int_impl!(i16);
int_impl!(i32);
int_impl!(i64);
int_impl!(i128);
int_impl!(isize);

macro_rules! float_impl {
    ($type:ident) => {
        impl TruncRoot for $type {
            fn trunc_sqrt(self) -> Self {
                self.sqrt().trunc()
            }
            fn trunc_cbrt(self) -> Self {
                self.cbrt().trunc()
            }
        }
        impl Root for $type {
            fn sqrt(self) -> Self {
                self.sqrt()
            }
            fn cbrt(self) -> Self {
                self.cbrt()
            }
        }
    };
}
float_impl!(f32);
float_impl!(f64);