rithm 14.6.0

Arbitrary precision arithmetic.
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

use crate::traits::TryDivAsFloat;

use super::digits::TryDivDigitsAsFloat;
use super::types::BigInt;

macro_rules! try_div_big_int_as_float_impl {
    ($($float:ty)*) => ($(
        impl<
                Digit: TryDivDigitsAsFloat<$float>,
                const DIGIT_BITNESS: usize,
            > TryDivAsFloat<Self, $float> for BigInt<Digit, DIGIT_BITNESS>
        {
            type Error = <Digit as TryDivDigitsAsFloat<$float>>::Error;

            fn try_div_as_float(
                self,
                divisor: Self,
            ) -> Result<$float, Self::Error> {
                Digit::checked_div_digits_as_float::<DIGIT_BITNESS>(
                    &self.digits,
                    &divisor.digits,
                )
                .map(|modulus| {
                    ((self.sign * divisor.sign) as $float) * modulus
                })
            }
        }

        impl<
                Digit: TryDivDigitsAsFloat<$float>,
                const DIGIT_BITNESS: usize,
            > TryDivAsFloat<&Self, $float>
            for BigInt<Digit, DIGIT_BITNESS>
        {
            type Error = <Digit as TryDivDigitsAsFloat<$float>>::Error;

            fn try_div_as_float(
                self,
                divisor: &Self,
            ) -> Result<$float, Self::Error> {
                Digit::checked_div_digits_as_float::<DIGIT_BITNESS>(
                    &self.digits,
                    &divisor.digits,
                )
                .map(|modulus| {
                    ((self.sign * divisor.sign) as $float) * modulus
                })
            }
        }

        impl<
                Digit: TryDivDigitsAsFloat<$float>,
                const DIGIT_BITNESS: usize,
            > TryDivAsFloat<BigInt<Digit, DIGIT_BITNESS>, $float>
            for &BigInt<Digit, DIGIT_BITNESS>
        {
            type Error = <Digit as TryDivDigitsAsFloat<$float>>::Error;

            fn try_div_as_float(
                self,
                divisor: BigInt<Digit, DIGIT_BITNESS>,
            ) -> Result<$float, Self::Error> {
                Digit::checked_div_digits_as_float::<DIGIT_BITNESS>(
                    &self.digits,
                    &divisor.digits,
                )
                .map(|modulus| {
                    ((self.sign * divisor.sign) as $float) * modulus
                })
            }
        }

        impl<
                Digit: TryDivDigitsAsFloat<$float>,
                const DIGIT_BITNESS: usize,
            > TryDivAsFloat<Self, $float>
            for &BigInt<Digit, DIGIT_BITNESS>
        {
            type Error = <Digit as TryDivDigitsAsFloat<$float>>::Error;

            fn try_div_as_float(
                self,
                divisor: Self,
            ) -> Result<$float, Self::Error> {
                Digit::checked_div_digits_as_float::<DIGIT_BITNESS>(
                    &self.digits,
                    &divisor.digits,
                )
                .map(|modulus| {
                    ((self.sign * divisor.sign) as $float) * modulus
                })
            }
        }
    )*)
}

try_div_big_int_as_float_impl!(f32 f64);