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


mod ln2;
mod ln10;
mod pi;
mod e;

use crate::BigFloatNumber;
use crate::Error;
use crate::RoundingMode;
use crate::ops::consts::e::ECache;
use crate::ops::consts::ln10::Ln10Cache;
use crate::ops::consts::ln2::Ln2Cache;
use crate::ops::consts::pi::PiCache;


/// Constants cache contains arbitrary-precision mathematical constants.
pub struct Consts {
    pi: PiCache,
    e: ECache,
    ln2: Ln2Cache,
    ln10: Ln10Cache,
}

/// In an ideal situation, the `Consts` structure is initialized with `Consts::new` only once,
/// and then used where needed.
impl Consts {

    /// Initializes the constants cache.
    ///
    /// ## Errors
    /// 
    ///  - MemoryAllocation: failed to allocate memory for mantissa.
    pub fn new() -> Result<Self, Error> {
        Ok(Consts {
            pi: PiCache::new()?,
            e: ECache::new()?,
            ln2: Ln2Cache::new()?,
            ln10: Ln10Cache::new()?,
        })
    }

    /// Returns the value of the pi number with precision `p` using rounding mode `rm`.
    ///
    /// ## Errors
    /// 
    ///  - MemoryAllocation: failed to allocate memory for mantissa.
    ///  - InvalidArgument: precision is incorrect.
    pub fn pi(&mut self, p: usize, rm: RoundingMode) -> Result<BigFloatNumber, Error> {
        self.pi.for_prec(p, rm)
    }

    /// Returns the value of the Euler number with precision `p` using rounding mode `rm`.
    ///
    /// ## Errors
    /// 
    ///  - MemoryAllocation: failed to allocate memory for mantissa.
    ///  - InvalidArgument: precision is incorrect.
    pub fn e(&mut self, p: usize, rm: RoundingMode) -> Result<BigFloatNumber, Error> {
        self.e.for_prec(p, rm)
    }

    /// Returns the value of the natural logarithm of 2 with precision `p` using rounding mode `rm`.
    ///
    /// ## Errors
    /// 
    ///  - MemoryAllocation: failed to allocate memory for mantissa.
    ///  - InvalidArgument: precision is incorrect.
    pub fn ln_2(&mut self, p: usize, rm: RoundingMode) -> Result<BigFloatNumber, Error> {
        self.ln2.for_prec(p, rm)
    }

    /// Returns the value of the natural logarithm of 10 with precision `p` using rounding mode `rm`.
    ///
    /// ## Errors
    /// 
    ///  - MemoryAllocation: failed to allocate memory for mantissa.
    ///  - InvalidArgument: precision is incorrect.
    pub fn ln_10(&mut self, p: usize, rm: RoundingMode) -> Result<BigFloatNumber, Error> {
        self.ln10.for_prec(p, rm)
    }
}