twibint 0.3.2

Crate for arithmetic on arbitrarily large integers. Provides Python bindings as well.
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

//! This module introduces some ergonomics for multiplying floats
//! when only caring for some amount of most significant digits.

use crate::traits::Digit;
use crate::BigFloat;
use crate::BigUint;

/// Meant to only be implemented by BigFloat, for the prupose of the
/// Newton-Raphson division
pub(super) trait SmartMul<T: Digit> {
    type MSDRep<'a>
    where
        Self: 'a;
    fn msd(&self, nb_digits: usize) -> Self::MSDRep<'_>;
    fn smart_mul<A: OpArgument<T>, B: OpArgument<T>>(&mut self, _a: A, _b: B) {
        unimplemented!()
    }
    fn smart_add_assign<A: OpArgument<T>>(&mut self, _a: A) {
        unimplemented!()
    }
}

impl<T: Digit> SmartMul<T> for BigFloat<T> {
    type MSDRep<'a> = BigFloatMSD<'a, T>;

    #[inline]
    fn msd(&self, nb_digits: usize) -> BigFloatMSD<'_, T> {
        BigFloatMSD {
            float: &self,
            nb_digits: nb_digits,
        }
    }

    #[inline]
    fn smart_mul<A: OpArgument<T>, B: OpArgument<T>>(&mut self, a: A, b: B) {
        let (a_sign, a_scale, a_data) = a.data();
        let (b_sign, b_scale, b_data) = b.data();
        self._set_to_mul(a_sign, a_scale, a_data, b_sign, b_scale, b_data);
    }

    #[inline]
    fn smart_add_assign<A: OpArgument<T>>(&mut self, a: A) {
        let (a_sign, a_scale, a_data) = a.data();
        self.add_assign(a_sign, a_scale, a_data);
    }
}

impl<T: Digit> SmartMul<T> for BigUint<T> {
    type MSDRep<'a> = BigUintMSD<'a, T>;

    #[inline]
    fn msd(&self, nb_digits: usize) -> BigUintMSD<'_, T> {
        BigUintMSD {
            uint: &self,
            nb_digits: nb_digits,
        }
    }
}

pub(super) trait OpArgument<T: Digit> {
    fn data(&self) -> (bool, isize, &[T]);
}

impl<T: Digit> OpArgument<T> for BigFloat<T> {
    #[inline]
    fn data(&self) -> (bool, isize, &[T]) {
        (self.int.sign, self.scale, &self.int.uint.val)
    }
}

impl<T: Digit> OpArgument<T> for &BigFloat<T> {
    #[inline]
    fn data(&self) -> (bool, isize, &[T]) {
        (self.int.sign, self.scale, &self.int.uint.val)
    }
}

impl<T: Digit> OpArgument<T> for BigUint<T> {
    #[inline]
    fn data(&self) -> (bool, isize, &[T]) {
        (true, 0, &self.val)
    }
}

impl<T: Digit> OpArgument<T> for &BigUint<T> {
    #[inline]
    fn data(&self) -> (bool, isize, &[T]) {
        (true, 0, &self.val)
    }
}

/// Represents the most significant digits of a BigFloat
pub(super) struct BigFloatMSD<'a, T: Digit> {
    float: &'a BigFloat<T>,
    nb_digits: usize,
}

impl<'a, T: Digit> OpArgument<T> for BigFloatMSD<'a, T> {
    #[inline]
    fn data(&self) -> (bool, isize, &[T]) {
        let offset = self.nb_digits.min(self.float.int.uint.val.len());
        let cutoff = self.float.int.uint.val.len() - offset;
        (
            self.float.int.sign,
            self.float.scale + (cutoff as isize),
            &self.float.int.uint.val[cutoff..],
        )
    }
}

/// Represents the most significant digits of a BigUint
pub(super) struct BigUintMSD<'a, T: Digit> {
    uint: &'a BigUint<T>,
    nb_digits: usize,
}

impl<'a, T: Digit> OpArgument<T> for BigUintMSD<'a, T> {
    #[inline]
    fn data(&self) -> (bool, isize, &[T]) {
        let offset = self.nb_digits.min(self.uint.val.len());
        let cutoff = self.uint.val.len() - offset;
        (true, cutoff as isize, &self.uint.val[cutoff..])
    }
}