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
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

use crate::{
    bint::{intrinsics::*, UInt},
    decimal::{
        dec::{
            construct::construct,
            math::{add::add, utils::correct},
            ExtraPrecision,
        },
        signals::Signals,
        Context, Decimal,
    },
};

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

#[inline(never)]
pub(crate) const fn mul<const N: usize>(mut lhs: D<N>, mut rhs: D<N>) -> D<N> {
    if lhs.is_nan() {
        return lhs.compound(&rhs).op_invalid();
    }

    if rhs.is_nan() {
        return rhs.compound(&lhs).op_invalid();
    }

    let sign = lhs.sign().mul(rhs.sign());
    let mut signals = Signals::combine(lhs.cb.get_signals(), rhs.cb.get_signals());
    let ctx = Context::merge(lhs.cb.get_context(), rhs.cb.get_context());

    if lhs.is_infinite() || rhs.is_infinite() {
        return if lhs.is_zero() || rhs.is_zero() {
            D::SIGNALING_NAN.set_ctx(ctx).compound(&lhs).compound(&rhs)
        } else {
            D::INFINITY.set_ctx(ctx).set_sign(sign)
        };
    }

    let mut exp = lhs.cb.get_exponent() + rhs.cb.get_exponent();

    let mut extra_precision = ExtraPrecision::new();

    if lhs.is_zero() || rhs.is_zero() {
        return construct(UInt::ZERO, exp, sign, signals, ctx, extra_precision);
    }

    let correction = if lhs.cb.has_extra_precision() || rhs.cb.has_extra_precision() {
        Some(mul_correction(&mut lhs, &mut rhs))
    } else {
        None
    };

    // TODO: Performance optimization
    // If overflows then we can try to truncate coefficient and make extra precision
    // in single (several) step instead of iteration looping divide by 10.
    // See `div` implementation.
    let (mut low, mut high) = lhs.digits.widening_mul(rhs.digits);

    if !high.is_zero() {
        signals.raise(Signals::OP_ROUNDED);

        let mut out;
        let mut rem;

        while !high.is_zero() {
            exp += 1;

            out = [0; N];
            rem = 0;

            let mut i = N;
            while i > 0 {
                i -= 1;
                let (q, r) = _div_rem_128_64(high.digits()[i], rem, 10);
                rem = r;
                out[i] = q;
            }

            high = UInt::from_digits(out);

            i = N;
            out = [0; N];

            while i > 0 {
                i -= 1;
                let (q, r) = _div_rem_128_64(low.digits()[i], rem, 10);
                rem = r;
                out[i] = q;
            }

            low = UInt::from_digits(out);

            if rem != 0 {
                signals.raise(Signals::OP_INEXACT);
            }

            extra_precision.push_digit(rem);
        }
    }

    let result = construct(low, exp, sign, signals, ctx, extra_precision);

    if let Some(correction) = correction {
        correct(result, correction)
    } else {
        result
    }
}

#[inline]
const fn mul_correction<const N: usize>(lhs: &mut D<N>, rhs: &mut D<N>) -> D<N> {
    let xi_lhs = lhs.cb.take_extra_precision_decimal();
    let xi_rhs = rhs.cb.take_extra_precision_decimal();

    if xi_lhs.is_zero() && xi_rhs.is_zero() {
        D::ZERO
    } else if xi_lhs.is_zero() {
        mul(*lhs, xi_rhs)
    } else if xi_rhs.is_zero() {
        mul(*rhs, xi_lhs)
    } else {
        add(
            mul(*lhs, xi_rhs),
            add(mul(*rhs, xi_lhs), mul(xi_rhs, xi_lhs)),
        )
    }
}