bigdecimal 0.4.10

Arbitrary precision decimal numbers
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

// Test BigDecimal::with_scale_round

macro_rules! impl_test {
    ( name=$($name:expr)*; $scale:literal : $mode:ident => $ex:literal ) => {
        paste! {
            #[test]
            fn [< $($name)* _rounding_ $mode >]() {
                let bigdecimal = test_input();
                let result = bigdecimal.with_scale_round($scale as i64, RoundingMode::$mode);
                let expected = BigDecimal::from_str($ex).unwrap();
                assert_eq!(result, expected);
                assert_eq!(result.int_val, expected.int_val);
                assert_eq!(result.scale, $scale);
            }
        }
    };
    ( -$scale:literal $( : $($modes:ident),+ => $ex:literal )+ ) => {
        $( $( impl_test!(name=scale_neg_ $scale; -$scale : $modes => $ex); )* )*
    };
    ( $scale:literal $( : $($modes:ident),+ => $ex:literal )+ ) => {
        $( $( impl_test!(name=scale_ $scale; $scale : $modes => $ex); )* )*
    };
}


mod case_3009788271450eNeg9 {
    use super::*;

    fn test_input() -> BigDecimal {
        BigDecimal::from_str("3009.788271450").unwrap()
    }

    impl_test!(10 : Up, Down => "3009.7882714500");
    impl_test!(9 : Up, Down => "3009.788271450");
    impl_test!(8 : Up, Down, HalfEven => "3009.78827145");

    impl_test!(7 : Up, Ceiling, HalfUp => "3009.7882715"
                 : Down, Floor, HalfDown, HalfEven => "3009.7882714");

    impl_test!(4 : Up, Ceiling, HalfUp, HalfDown, HalfEven => "3009.7883"
                 : Down, Floor => "3009.7882");

    impl_test!(2 : Up => "3009.79"
                 : Down => "3009.78");

    impl_test!(1 : Up => "3009.8"
                 : Down => "3009.7");

    impl_test!(0 : Up => "3010"
                 : Down => "3009");

    impl_test!( -1 : Up => "301e1");
    impl_test!( -2 : Up => "31e2");
    impl_test!( -3 : Up => "4e3");
    impl_test!( -4 : Up => "1e4" );
    impl_test!( -5 : Up => "1e5" : Down => "0");
    impl_test!( -20 : Up => "1e20" : Down => "0");
}

mod case_neg_636652287787259 {
    use super::*;

    fn test_input() -> BigDecimal {
        BigDecimal::from_str("-636652287787259").unwrap()
    }

    impl_test!(1 : Up, Down => "-636652287787259.0");
    impl_test!(0 : Up, Down => "-636652287787259");
    impl_test!(-1 : Up => "-63665228778726e1"
                  : Down => "-63665228778725e1");
    impl_test!(-12 : Up => "-637e12"
                  : Down => "-636e12");
}

mod case_99999999999999999999999eNeg4 {
    use super::*;

    fn test_input() -> BigDecimal {
        BigDecimal::from_str("99999999999999999999999e-4").unwrap()
    }

    impl_test!(4 : Up => "9999999999999999999.9999");
    impl_test!(3 : Up => "10000000000000000000.000"
                 : Down => "9999999999999999999.999");
    impl_test!(-3 : Up => "10000000000000000e3"
                  : Down => "9999999999999999e3");
}

mod case_369708962060657eNeg30 {
    use super::*;

    fn test_input() -> BigDecimal {
        BigDecimal::from_str("369708962060657E-30").unwrap()
    }

    impl_test!(4 : Up => "1e-4");
    impl_test!(20 : Up => "36971e-20"
                  : Down => "36970e-20");
}

mod case_682829560896740e30 {
    use super::*;

    fn test_input() -> BigDecimal {
        BigDecimal::from_str("682829560896740e30").unwrap()
    }

    impl_test!(4 : Up => "682829560896740000000000000000000000000000000.0000");
    impl_test!(0 : Up => "682829560896740000000000000000000000000000000");
    impl_test!(-35 : Up => "6828295609e35");
    impl_test!(-36 : Up => "682829561e36");
    impl_test!(-100 : Up => "1e100");
}