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

use rug::Integer;
use std::cmp::Ordering;

use crate::{rfloat::RFloat, Real};

use super::FloatContext;

/// Exception flags to signal properties of a rounded result.
///
/// Similar to IEEE 754 style exceptions, except we have
/// no constraints on exponent so we only have four exceptions:
///
/// - _invalid operation_: no useful definable result;
/// - _division by zero_: an infinite result for finite arguments;
/// - _inexact_: result would be different had both the exponent range
///     and precision been unbounded.
/// - _carry_: the exponent of the rounded result when in the form
///     `(-1)^s * c * b^exp` is different than that of the truncated result.
///     In particular, it was incremented by 1 by the rounding operation.
///
#[derive(Clone, Debug, Default)]
pub struct Exceptions {
    pub invalid: bool,
    pub divzero: bool,
    pub inexact: bool,
    pub carry: bool,
}

impl Exceptions {
    /// Constructs a new set of exceptions.
    /// All flags are set to false.
    pub fn new() -> Self {
        Self {
            invalid: false,
            divzero: false,
            inexact: false,
            carry: false,
        }
    }
}

/// A fixed-precision, floating-point number with unbounded exponent.
///
/// The associated [`RoundingContext`][crate::RoundingContext]
/// implementation is [`FloatContext`][crate::float::FloatContext].
/// See [`FloatContext`] for more details on numerical properties
/// of the [`Float`] type.
///
/// A [`Float`] also has an [`Exceptions`] instance to indicate
/// exceptional events that occured during its construction.
#[derive(Debug, Clone)]
pub struct Float {
    pub(crate) num: RFloat,
    pub(crate) flags: Exceptions,
    pub(crate) ctx: FloatContext,
}

impl Float {
    /// Return the flags set when this number was created.
    pub fn flags(&self) -> &Exceptions {
        &self.flags
    }

    /// Returns the rounding context under which this number was created.
    pub fn ctx(&self) -> &FloatContext {
        &self.ctx
    }
}

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

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

    fn exp(&self) -> Option<isize> {
        self.num.exp()
    }

    fn e(&self) -> Option<isize> {
        self.num.e()
    }

    fn n(&self) -> Option<isize> {
        self.num.n()
    }

    fn c(&self) -> Option<Integer> {
        self.num.c()
    }

    fn m(&self) -> Option<Integer> {
        self.num.m()
    }

    fn prec(&self) -> Option<usize> {
        self.num.prec()
    }

    fn is_nar(&self) -> bool {
        self.num.is_nar()
    }

    fn is_finite(&self) -> bool {
        self.num.is_finite()
    }

    fn is_infinite(&self) -> bool {
        self.num.is_finite()
    }

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

    fn is_negative(&self) -> Option<bool> {
        self.num.is_negative()
    }

    fn is_numerical(&self) -> bool {
        self.num.is_numerical()
    }
}

impl From<Float> for RFloat {
    fn from(value: Float) -> Self {
        value.num
    }
}

impl From<Float> for rug::Float {
    fn from(value: Float) -> Self {
        rug::Float::from(value.num)
    }
}

impl PartialOrd for Float {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        self.num.partial_cmp(&other.num)
    }
}

impl PartialEq for Float {
    fn eq(&self, other: &Self) -> bool {
        self.partial_cmp(other) == Some(Ordering::Equal)
    }
}