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

use crate::{
    rfloat::{RFloat, RFloatContext},
    Real, RoundingContext, RoundingMode, Split,
};

use super::{Exceptions, Float};

/// Rounding contexts for fixed-precision, floating-point numbers
/// with unbounded exponent.
///
/// The associated storage type is [`Float`].
///
/// This is not IEEE 754 style rounding:
/// values rounded under this context are base-2 scientific numbers
/// `(-1)^s * c * 2^exp` where `c` is a fixed-precision unsigned integer
/// and `exp` is an unbounded signed integer.
///
/// A [`FloatContext`] is parameterized by
///
///  - maximum precision (see [`Real::prec`]),
///  - rounding mode.
///
/// By default, the rounding mode is [`RoundingMode::NearestTiesToEven`].
/// This rounding context is similar to the one implemented by
/// [Rug](https://docs.rs/rug/latest/rug/) (MPFR).
///
#[derive(Clone, Debug)]
pub struct FloatContext {
    prec: usize,
    rm: RoundingMode,
}

impl FloatContext {
    /// Constructs a new rounding context.
    pub fn new(prec: usize) -> Self {
        Self {
            prec,
            rm: RoundingMode::NearestTiesToEven,
        }
    }

    /// Sets the precision of this context.
    pub fn with_max_p(mut self, prec: usize) -> Self {
        self.prec = prec;
        self
    }

    /// Sets the rounding mode of this context.
    pub fn with_rm(mut self, rm: RoundingMode) -> Self {
        self.rm = rm;
        self
    }

    /// Returns the maximum precision allowed by this format.
    pub fn max_p(&self) -> usize {
        self.prec
    }

    /// Returns the rounding mode of this context.
    pub fn rm(&self) -> RoundingMode {
        self.rm
    }
}

impl RoundingContext for FloatContext {
    type Format = Float;

    fn round<T: Real>(&self, val: &T) -> Self::Format {
        // case split by class
        if val.is_zero() {
            Float {
                num: RFloat::zero(),
                flags: Exceptions::default(),
                ctx: self.clone(),
            }
        } else if val.is_infinite() {
            if val.sign().unwrap() {
                Float {
                    num: RFloat::NegInfinity,
                    flags: Exceptions::default(),
                    ctx: self.clone(),
                }
            } else {
                Float {
                    num: RFloat::PosInfinity,
                    flags: Exceptions::default(),
                    ctx: self.clone(),
                }
            }
        } else if val.is_nar() {
            Float {
                num: RFloat::Nan,
                flags: Exceptions::default(),
                ctx: self.clone(),
            }
        } else {
            // step 1: rounding as an unbounded, fixed-precision floating-point,
            // so we need to compute the context parameters; we only set
            // `max_p` when rounding with a RFloatContext.
            let (p, n) = RFloatContext::new()
                .with_max_p(self.max_p())
                .round_params(val);

            // step 2: split the significand at binary digit `n`
            let split = Split::new(val, p, n);

            // step 3: extract split parameters and inexactness flag
            let inexact = !split.is_exact();
            let unrounded_e = split.e();

            // step 4: finalize (unbounded exponent)
            let rounded = RFloatContext::round_finalize(split, self.rm);

            // step 5: carry flag
            let carry = match (unrounded_e, rounded.e()) {
                (Some(e1), Some(e2)) => e2 > e1,
                (_, _) => false,
            };

            // step 6: compose result
            Float {
                num: rounded,
                flags: Exceptions {
                    inexact,
                    carry,
                    ..Default::default()
                },
                ctx: self.clone(),
            }
        }
    }
}