mpmfnum 0.2.0

A numbers library 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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

use num_traits::Zero;
use rug::Integer;

use crate::rfloat::RFloat;
use crate::Real;

/// An exact sum of two [`Real`] values split at an absolute binary digit.
#[derive(Clone, Debug)]
pub struct Split {
    high: RFloat,
    low: RFloat,
    max_p: Option<usize>,
    split_pos: isize,
}

impl Split {
    /// Splits a [`Real`] at binary digit `n` into two [`RFloat`] values:
    ///
    ///  - all significant digits above position `n`
    ///  - all significant digits at or below position `n`
    ///
    /// The sum of the resulting values will be exactly the input number,
    /// that is, it "splits" a number.
    pub fn new<T: Real>(num: &T, max_p: Option<usize>, n: isize) -> Self {
        assert!(!num.is_nar(), "must be real {:?}", num);
        let (high, low) = num.split(n);
        Self {
            high,
            low,
            max_p,
            split_pos: n,
        }
    }

    /// Extracts the upper value of the split.
    pub fn num(&self) -> &RFloat {
        &self.high
    }

    /// Extracts the lower value of the split.
    pub fn lost(&self) -> &RFloat {
        &self.low
    }

    /// The precision of the upper value of the split.
    pub fn max_p(&self) -> Option<usize> {
        self.max_p
    }

    /// The position of the first digit lost in the split.
    pub fn split_pos(&self) -> isize {
        self.split_pos
    }

    /// Extracts the round, guard, and sticky bit ("RGS") from lost digits.
    pub fn rgs(&self) -> (bool, bool, bool) {
        let (half, lower) = self.low.split(self.split_pos - 1);
        let (quarter, lower) = lower.split(self.split_pos - 2);
        (!half.is_zero(), !quarter.is_zero(), !lower.is_zero())
    }

    /// Extracts the round and sticky bit ("RGS") from lost digits.
    pub fn rs(&self) -> (bool, bool) {
        let (half, lower) = self.low.split(self.split_pos - 1);
        (!half.is_zero(), !lower.is_zero())
    }

    /// Returns `true` if the lost digits are all zero.
    pub fn is_exact(&self) -> bool {
        self.low.is_zero()
    }
}

impl Real for Split {
    fn radix() -> usize {
        2
    }

    fn sign(&self) -> Option<bool> {
        self.high.sign()
    }

    fn exp(&self) -> Option<isize> {
        match self.low.exp() {
            Some(exp) => Some(exp),
            None => self.high.exp(),
        }
    }

    fn e(&self) -> Option<isize> {
        match self.high.e() {
            Some(e) => Some(e),
            None => self.low.e(),
        }
    }

    fn n(&self) -> Option<isize> {
        match self.low.n() {
            Some(n) => Some(n),
            None => self.high.n(),
        }
    }

    fn c(&self) -> Option<Integer> {
        match (self.high.is_zero(), self.low.is_zero()) {
            (true, true) => Some(Integer::zero()),
            (false, true) => self.high.c(),
            (true, false) => self.low.c(),
            (false, false) => {
                let c1 = self.high.c().unwrap();
                let c2 = self.low.c().unwrap();
                let offset = self.high.exp().unwrap() - self.low.exp().unwrap();
                Some((c1 << offset) + c2)
            }
        }
    }

    fn m(&self) -> Option<Integer> {
        self.c().map(|c| if self.sign().unwrap() { -c } else { c })
    }

    fn prec(&self) -> Option<usize> {
        match (self.e(), self.n()) {
            (None, None) => None,
            (Some(e), Some(n)) => Some((e - n) as usize),
            (_, _) => panic!("unreachable"),
        }
    }

    fn is_nar(&self) -> bool {
        false
    }

    fn is_finite(&self) -> bool {
        true
    }

    fn is_infinite(&self) -> bool {
        false
    }

    fn is_zero(&self) -> bool {
        self.high.is_zero() && self.low.is_zero()
    }

    fn is_negative(&self) -> Option<bool> {
        match self.high.is_negative() {
            Some(b) => Some(b),
            None => self.low.is_negative(),
        }
    }

    fn is_numerical(&self) -> bool {
        true
    }
}