fixnum 0.9.5

Fixed-point numbers with explicit rounding
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

use crate::{layout::Promotion, ops::Zero};

pub(crate) trait Sqrt: Promotion {
    fn sqrt(self) -> Self::Layout;
}

macro_rules! impl_sqrt {
    ($prom:ty) => {
        impl Sqrt for $prom {
            /// Checked integer square root.
            /// Sqrt implementation courtesy of [`num` crate][num].
            ///
            /// [num]: https://github.com/rust-num/num-integer/blob/4d166cbb754244760e28ea4ce826d54fafd3e629/src/roots.rs#L278
            #[inline]
            fn sqrt(self) -> Self::Layout {
                type Layout = <$prom as Promotion>::Layout;

                #[cfg(feature = "std")]
                #[inline]
                fn guess(v: $prom) -> Layout {
                    v.as_positive_f64().sqrt() as Layout
                }

                #[cfg(not(feature = "std"))]
                #[inline]
                fn guess(v: $prom) -> Layout {
                    #[inline]
                    fn log2_estimate(v: $prom) -> u32 {
                        debug_assert!(v > <$prom as Zero>::ZERO);
                        (core::mem::size_of::<$prom>() as u32 * 8) - 1 - v.leading_zeros()
                    }

                    1 << ((log2_estimate(v) + 1) / 2)
                }

                #[inline]
                fn fixpoint(mut x: Layout, f: impl Fn(Layout) -> Layout) -> Layout {
                    let mut xn = f(x);
                    while x < xn {
                        x = xn;
                        xn = f(x);
                    }
                    while x > xn {
                        x = xn;
                        xn = f(x);
                    }
                    x
                }

                debug_assert!(self >= <$prom as Zero>::ZERO);

                if self < <$prom>::from(4i8) {
                    return ((self > <$prom as Zero>::ZERO) as i8).into();
                }

                // https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
                let next = |x: Layout| (self.div_l(x).as_layout() + x) >> 1;
                fixpoint(guess(self), next)
            }
        }
    };
}

#[cfg(feature = "i16")]
impl_sqrt!(i32);
#[cfg(feature = "i32")]
impl_sqrt!(i64);
#[cfg(feature = "i64")]
impl_sqrt!(i128);
#[cfg(feature = "i128")]
impl_sqrt!(crate::i256);