dashu-float 0.4.3

A big float library supporting arbitrary precision, arbitrary base and arbitrary rounding mode
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

//! Helper macros for constructing numbers
//!
//! These macros are the simpler versions of the ones in `dashu-macros`, meant
//! to be used in testing only. These macros don't support the radix point.
//!
//! These macros rely on string parsing, so do not use
//! these macros when testing string parsing!

#[macro_export]
macro_rules! ubig {
    ($val:tt) => {{
        const STR: &::core::primitive::str = ::core::stringify!($val);
        ::core::result::Result::expect(
            ::dashu_int::UBig::from_str_with_radix_prefix(STR),
            "invalid number",
        )
        .0
    }};
    ($val:tt base $radix:literal) => {{
        const STR: &::core::primitive::str = ::core::stringify!($val);
        let s =
            ::core::option::Option::unwrap_or(::core::primitive::str::strip_prefix(STR, "_"), STR);
        ::core::result::Result::expect(
            ::dashu_int::UBig::from_str_radix(s, $radix),
            "invalid number",
        )
    }};
}

#[macro_export]
macro_rules! ibig {
    (- $val:tt) => {
        - <::dashu_int::IBig as ::core::convert::From<::dashu_int::UBig>>::from($crate::ubig!($val))
    };
    (- $val:tt base $radix:literal) => {
        - <::dashu_int::IBig as ::core::convert::From<::dashu_int::UBig>>::from(
            $crate::ubig!($val base $radix)
        )
    };
    ($val:tt) => {
        <::dashu_int::IBig as ::core::convert::From<::dashu_int::UBig>>::from($crate::ubig!($val))
    };
    ($val:tt base $radix:literal) => {
        <::dashu_int::IBig as ::core::convert::From<::dashu_int::UBig>>::from(
            $crate::ubig!($val base $radix)
        )
    };
}

/// Create a FBig instance with base 2 from literal, note that this macro doesn't support the float point.
#[macro_export]
macro_rules! fbig {
    ($val:tt) => {{
        const STR: &::core::primitive::str = ::core::stringify!($val);
        let stripped = STR.strip_prefix('_').unwrap_or(STR);
        ::core::result::Result::expect(
            <::dashu_float::FBig as ::core::str::FromStr>::from_str(stripped),
            "invalid number",
        )
    }};
    ($val:tt - $exp:literal) => {{
        const VAL_STR: &::core::primitive::str = ::core::stringify!($val);
        const EXP_STR: &::core::primitive::str = ::core::stringify!($exp);
        let stripped = VAL_STR.strip_prefix('_').unwrap_or(VAL_STR);
        let concat = [stripped, &"-", EXP_STR].concat();
        ::core::result::Result::expect(
            <::dashu_float::FBig as ::core::str::FromStr>::from_str(&concat),
            "invalid number",
        )
    }};
    (-$val:tt) => {{
        const STR: &::core::primitive::str = ::core::stringify!($val);
        let stripped = STR.strip_prefix('_').unwrap_or(STR);
        -::core::result::Result::expect(
            <::dashu_float::FBig as ::core::str::FromStr>::from_str(stripped),
            "invalid number",
        )
    }};
    (-$val:tt - $exp:literal) => {{
        const VAL_STR: &::core::primitive::str = ::core::stringify!($val);
        const EXP_STR: &::core::primitive::str = ::core::stringify!($exp);
        let stripped = VAL_STR.strip_prefix('_').unwrap_or(VAL_STR);
        let concat = [stripped, &"-", EXP_STR].concat();
        -::core::result::Result::expect(
            <::dashu_float::FBig as ::core::str::FromStr>::from_str(&concat),
            "invalid number",
        )
    }};
}

/// Create a DBig instance from literal, note that this macro doesn't support the float point.
#[macro_export]
macro_rules! dbig {
    ($val:tt) => {{
        const STR: &::core::primitive::str = ::core::stringify!($val);
        ::core::result::Result::expect(
            <::dashu_float::DBig as ::core::str::FromStr>::from_str(STR),
            "invalid number",
        )
    }};
    ($val:tt - $exp:literal) => {{
        const VAL_STR: &::core::primitive::str = ::core::stringify!($val);
        const EXP_STR: &::core::primitive::str = ::core::stringify!($exp);
        let concat = [VAL_STR, &"-", EXP_STR].concat();
        ::core::result::Result::expect(
            <::dashu_float::DBig as ::core::str::FromStr>::from_str(&concat),
            "invalid number",
        )
    }};
    (-$val:tt) => {{
        const STR: &::core::primitive::str = ::core::stringify!($val);
        -::core::result::Result::expect(
            <::dashu_float::DBig as ::core::str::FromStr>::from_str(STR),
            "invalid number",
        )
    }};
    (-$val:tt - $exp:literal) => {{
        const VAL_STR: &::core::primitive::str = ::core::stringify!($val);
        const EXP_STR: &::core::primitive::str = ::core::stringify!($exp);
        let concat = [VAL_STR, &"-", EXP_STR].concat();
        -::core::result::Result::expect(
            <::dashu_float::DBig as ::core::str::FromStr>::from_str(&concat),
            "invalid number",
        )
    }};
}