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

use crate::decimal::{
    dec::{
        convert::to_f64,
        intrinsics::Intrinsics,
        math::{add::add, div::div, mul::mul},
        parse::{from_f64, from_u32},
    },
    utils::types,
    Decimal,
};

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

#[inline]
pub(crate) const fn nth_root<const N: usize>(d: D<N>, n: u32) -> D<N> {
    if d.is_nan() {
        return d.op_invalid();
    }

    if d.is_zero() || d.is_one() {
        return d;
    }

    if d.is_negative() {
        return d.signaling_nan();
    }

    if d.is_infinite() {
        return d;
    }

    nth_root_newton(d, n).set_ctx(d.context())
}

#[inline]
const fn nth_root_newton<const N: usize>(d: D<N>, n: u32) -> D<N> {
    let approx_f64 = to_f64(d);
    let guess = types::f64::sqrt(approx_f64);

    let mut result = from_f64(guess).compound(&d);

    let mut result_next;

    let n_minus_one = from_u32(n - 1);
    let one_div_n = div(D::ONE, from_u32(n));
    let mut x_n;
    let mut j;
    let mut i = 1;

    while result.is_ok() && i < Intrinsics::<N>::SERIES_MAX_ITERATIONS {
        x_n = result;
        j = n - 2;

        while j > 0 {
            x_n = mul(x_n, result);
            j -= 1;
        }

        result_next = mul(one_div_n, add(mul(n_minus_one, result), div(d, x_n)));

        if result.eq(&result_next) {
            break;
        }

        result = result_next;
        i += 1;
    }

    result
}