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

#![doc = include_str!("../README.md")]
#![cfg_attr(not(feature = "std"), no_std)]
use core::fmt::{Binary, Debug, Display, Octal, UpperHex};
use core::marker::PhantomData;

mod cast;
mod ctx;
mod impls;
mod ops;

// Re-exports
pub use crate::ctx::BigFloatCtx;
pub use crate::ctx::ConstCtx;
pub use crate::impls::num_traits::ParseBigFloatError;
pub use astro_float;
pub use astro_float::RoundingMode;
pub use astro_float::Sign;
pub use astro_float::EXPONENT_MAX;
pub use astro_float::EXPONENT_MIN;
pub use nalgebra;
pub use num_traits;

/// Arbitrary precision float type that is a wrapper around [`astro_float::BigFloat`]. Has trait
/// implementations to be used with [nalgebra] and [num_traits].
///
/// BigFloat has a type parameter (CTX) that can be either [`ConstCtx`] if the precision and
/// rounding mode is known at compile-time. Or one can be created with
/// [`make_dyn_ctx`] if the precision or rounding mode are not known at
/// compile time.
///
/// One limitation with this library is that only BigFloats with the same CTX parameter are allowed
/// to interop. This means that the precision of a computation system cannot be changed without
/// explicitly casting all variables.
///
/// **NOTE:** It is recommended to make a type alias such as the one below.
///
/// ## Example
/// ```rust
/// use astro_nalgebra::{BigFloat, ConstCtx};
///
/// type BF128 = BigFloat<ConstCtx<128>>;
///
/// let ten: BF128 = "10".parse().unwrap();
/// let seven: BF128 = "7".parse().unwrap();
/// println!("{}", ten / seven);
/// ```
///
/// [nalgebra]: https://docs.rs/nalgebra
/// [num_traits]: https://docs.rs/num_traits
#[derive(Eq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BigFloat<CTX: BigFloatCtx> {
    pub(crate) num: astro_float::BigFloat,
    pub(crate) _pd: PhantomData<fn() -> CTX>,
}

impl<CTX: BigFloatCtx> From<astro_float::BigFloat> for BigFloat<CTX> {
    #[inline]
    fn from(value: astro_float::BigFloat) -> Self {
        BigFloat {
            num: value,
            _pd: PhantomData,
        }
    }
}

impl<CTX: BigFloatCtx> Clone for BigFloat<CTX> {
    #[inline]
    fn clone(&self) -> Self {
        BigFloat {
            num: self.num.clone(),
            _pd: PhantomData,
        }
    }
}
impl<CTX: BigFloatCtx> PartialEq for BigFloat<CTX> {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.num == other.num
    }
}

macro_rules! impl_display_wrapper {
    ($trait_name:ident) => {
        #[doc(hidden)]
        impl<CTX: BigFloatCtx> core::fmt::$trait_name for BigFloat<CTX> {
            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                <astro_float::BigFloat as $trait_name>::fmt(&self.num, f)
            }
        }
    };
}
// Wrapper around Display method on BigFloat
impl_display_wrapper!(Debug);
impl_display_wrapper!(Display);
impl_display_wrapper!(Binary);
impl_display_wrapper!(Octal);
impl_display_wrapper!(UpperHex);