num-bigfloat 1.7.2

Increased precision floating point numbers implemented purely in Rust.
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

//! Square root.

use crate::defs::BigFloatNum;
use crate::defs::Error;

impl BigFloatNum {
    /// Return square root of a number.
    ///
    /// # Errors
    ///
    /// Returns ArgumentIsNegative if `self` is less than 0.
    pub fn sqrt(&self) -> Result<Self, Error> {
        let arg = Self::to_big_float_inc(self);
        let ret = arg.sqrt()?;
        Self::from_big_float_inc(ret)
    }
}

#[cfg(test)]
mod tests {

    use super::*;
    use crate::defs::DECIMAL_POSITIONS;
    use crate::defs::DECIMAL_SIGN_NEG;

    #[test]
    fn test_sqrt() {
        let mut d1;

        let mut epsilon = BigFloatNum::one();
        epsilon.e = -epsilon.n as i8 + 1 - (DECIMAL_POSITIONS as i8);

        d1 = BigFloatNum::new();
        d1.m[0] = 10;
        d1.n = 2;
        let ret = d1.sqrt().unwrap();
        let ret = ret.mul(&ret).unwrap();
        assert!(d1.sub(&ret).unwrap().abs().cmp(&epsilon) <= 0);

        // sqrt(1234567890.1234567 = 1.2345...+10^9)
        d1 = BigFloatNum::new();
        d1.m[0] = 4567;
        d1.m[1] = 123;
        d1.m[2] = 6789;
        d1.m[3] = 2345;
        d1.m[4] = 1;
        d1.n = 17;
        d1.e = -7;
        let ret = d1.sqrt().unwrap();
        let ret = ret.mul(&ret).unwrap();
        epsilon.e = -69; // 1*10^(-30)
        assert!(d1.sub(&ret).unwrap().abs().cmp(&epsilon) <= 0);

        // positive exponent
        d1 = BigFloatNum::new();
        d1.m[0] = 4567;
        d1.m[1] = 123;
        d1.m[2] = 6789;
        d1.m[3] = 2345;
        d1.m[4] = 1;
        d1.n = 17;
        d1.e = 7;
        let ret = d1.sqrt().unwrap();
        let ret = ret.mul(&ret).unwrap();
        epsilon.e = -55; // 1*10^(-16)
        assert!(d1.sub(&ret).unwrap().abs().cmp(&epsilon) <= 0);

        // value less than 1
        d1 = BigFloatNum::new();
        d1.m[0] = 4567;
        d1.m[1] = 123;
        d1.m[2] = 6789;
        d1.m[3] = 2345;
        d1.m[4] = 1;
        d1.n = 17;
        d1.e = -20;
        let ret = d1.sqrt().unwrap();
        let ret = ret.mul(&ret).unwrap();
        epsilon.e = -82; // 1*10^(-43)
        assert!(d1.sub(&ret).unwrap().abs().cmp(&epsilon) <= 0);

        // value is negative
        d1 = BigFloatNum::new();
        d1.sign = DECIMAL_SIGN_NEG;
        assert!(d1.sqrt().unwrap_err() == Error::ArgumentIsNegative);

        let mut ret;
        let mut d1 = BigFloatNum::new();
        d1.m[0] = 4560;
        d1.m[1] = 123;
        d1.m[2] = 6789;
        d1.m[3] = 2345;
        d1.m[4] = 651;
        d1.m[5] = 41;
        d1.m[6] = 671;
        d1.m[7] = 100;
        d1.m[8] = 0;
        d1.m[9] = 0;
        d1.n = 32;
        d1.e = -36;
        epsilon.e = -epsilon.n as i8 + 3 - (DECIMAL_POSITIONS as i8);
        for i in 1..8000 {
            d1.m[8] = 10 + i;
            d1.m[9] = i;
            d1.n = if i < 10 {
                1
            } else if i < 100 {
                2
            } else if i < 1000 {
                3
            } else {
                4
            } + 36;
            ret = d1.sqrt().unwrap();
            ret = ret.mul(&ret).unwrap();
            assert!(
                ret.div(&d1)
                    .unwrap()
                    .sub(&BigFloatNum::one())
                    .unwrap()
                    .abs()
                    .cmp(&epsilon)
                    <= 0
            );
        }
    }
}