dashu-int 0.6.0

Arbitrary-precision integer math library for Rust, balancing ergonomics and efficiency. Provides UBig and IBig (unsigned and signed), with small values inlined on the stack. Efficient arithmetic, modular arithmetic, and number theory (pow, ilog, gcd, gcd_ext); two's-complement bit operations; parsing and formatting in base 2-36; optional serde, rand, num-traits, rkyv, and zeroize.
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

use dashu_base::{DivRem, DivRemAssign, Sign::Negative};
use dashu_int::fast_div::ConstDivisor;

mod helper_macros;

#[test]
fn test_value() {
    let ring = ConstDivisor::new(ubig!(100));
    assert_eq!(ring.value(), ubig!(100));

    let ring = ConstDivisor::new(ubig!(10).pow(100));
    assert_eq!(ring.value(), ubig!(10).pow(100));
}

#[test]
fn test_const_div() {
    let divisors = [
        ubig!(1),
        ubig!(2),
        ubig!(3),
        ubig!(127),
        ubig!(12345),
        (ubig!(1) << 32) - ubig!(1),
        (ubig!(1) << 64) - ubig!(1),
        (ubig!(1) << 128) - ubig!(1),
        (ubig!(1) << 256) - ubig!(1),
    ];

    let numbers = [
        ubig!(0),
        ubig!(1),
        ubig!(2),
        ubig!(3),
        ubig!(3).pow(5),
        ubig!(3).pow(10),
        ubig!(3).pow(20),
        ubig!(3).pow(40),
        ubig!(3).pow(80),
        ubig!(3).pow(120),
        ubig!(3).pow(160),
    ];

    for d in &divisors {
        let const_d = &(ConstDivisor::new(d.clone()));
        for n in &numbers {
            assert_eq!(n / d, n / const_d);
            assert_eq!(n / d, n.clone() / const_d);
            assert_eq!(n % d, n % const_d);
            assert_eq!(n % d, n.clone() % const_d);
            assert_eq!(n.div_rem(d), n.div_rem(const_d));
            assert_eq!(n.div_rem(d), n.clone().div_rem(const_d));

            let mut x = n.clone();
            x /= const_d;
            assert_eq!(x, n / d);

            let mut x = n.clone();
            x %= const_d;
            assert_eq!(x, n % d);

            let mut x = n.clone();
            assert_eq!(x.div_rem_assign(const_d), n % d);
            assert_eq!(x, n / d);

            let i = &(Negative * n.clone());
            assert_eq!(i / d, i / const_d);
            assert_eq!(i / d, i.clone() / const_d);
            assert_eq!(i % d, i % const_d);
            assert_eq!(i % d, i.clone() % const_d);
            // assert_eq!(i.div_rem(d), n.div_rem(const_d));
            // assert_eq!(i.div_rem(d), n.clone().div_rem(const_d));

            let mut x = i.clone();
            x /= const_d;
            assert_eq!(x, i / d);

            let mut x = i.clone();
            x %= const_d;
            assert_eq!(x, i % d);

            let mut x = i.clone();
            assert_eq!(x.div_rem_assign(const_d), i % d);
            assert_eq!(x, i / d);
        }
    }
}