fastnum 0.7.4

Fast decimal numbers library
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

use crate::decimal::{
    dec::math::{add::add, sub::sub},
    Decimal,
    RoundingMode::*,
};

type D<const N: usize> = Decimal<N>;

#[inline(always)]
pub(crate) const fn round<const N: usize>(d: &mut D<N>) {
    if !matches!(d.cb.get_rounding_mode(), No) {
        let digit = d.cb.take_round_reminder();

        if digit != 0
            && match d.cb.get_rounding_mode() {
                No => unreachable!(),
                Up => true,
                Down => false,
                Ceiling => !d.cb.is_negative(),
                Floor => d.cb.is_negative(),
                HalfUp => digit >= 5,
                HalfDown => digit > 5,
                HalfEven => {
                    if digit > 5 {
                        true
                    } else if digit == 5 {
                        let last_digit = d.digits.digits()[0];
                        let last_bit = last_digit & 0x0000_0000_0000_0001_u64;
                        last_bit != 0
                    } else {
                        false
                    }
                }
            }
        {
            if d.digits.is_max() {
                d.digits = d.digits.div_digit(10);
                d.cb.dec_scale(1);
            }

            d.digits = d.digits.strict_add_digit(1);
        }
    }
}

#[inline]
pub(crate) const fn floor<const N: usize>(d: D<N>) -> D<N> {
    if d.cb.is_special() {
        return d.signaling_nan();
    }

    if d.is_integral() {
        d
    } else {
        let rounded = d.with_rounding_mode(Down).round(0);
        if d.is_negative() {
            sub(rounded, D::ONE).round_extra_precision().check()
        } else {
            rounded
        }
    }
}

#[inline]
pub(crate) const fn ceil<const N: usize>(d: D<N>) -> D<N> {
    if d.cb.is_special() {
        return d.signaling_nan();
    }

    if d.is_integral() {
        d
    } else {
        let rounded = d.with_rounding_mode(Down).round(0);
        if d.is_negative() {
            rounded
        } else {
            add(rounded, D::ONE).round_extra_precision().check()
        }
    }
}