dashu-int 0.6.0-rc.4

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
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! Operators on the sign of [IBig].

use crate::{
    ibig::IBig,
    ops::{Abs, UnsignedAbs},
    ubig::UBig,
};
use core::ops::{Mul, MulAssign, Neg};
use dashu_base::{Sign, Signed};

impl IBig {
    /// A number representing the sign of `self`.
    ///
    /// * [IBig::ONE] if the number is positive
    /// * [IBig::ZERO] if the number is zero
    /// * [IBig::NEG_ONE] if the number is negative
    ///
    /// # Examples
    /// ```
    /// # use dashu_int::IBig;
    /// assert_eq!(IBig::from(-500).signum(), IBig::from(-1));
    /// ```
    #[inline]
    pub const fn signum(&self) -> IBig {
        IBig(self.0.signum())
    }
}

impl Neg for UBig {
    type Output = IBig;

    #[inline]
    fn neg(self) -> IBig {
        IBig(self.0.neg())
    }
}

impl Neg for IBig {
    type Output = IBig;

    #[inline]
    fn neg(self) -> IBig {
        IBig(self.0.neg())
    }
}

impl Neg for &UBig {
    type Output = IBig;

    #[inline]
    fn neg(self) -> IBig {
        IBig(self.0.clone().neg())
    }
}

impl Neg for &IBig {
    type Output = IBig;

    #[inline]
    fn neg(self) -> IBig {
        IBig(self.0.clone().neg())
    }
}

impl Abs for IBig {
    type Output = IBig;

    #[inline]
    fn abs(self) -> IBig {
        IBig(self.0.with_sign(Sign::Positive))
    }
}

impl Abs for &IBig {
    type Output = IBig;

    #[inline]
    fn abs(self) -> IBig {
        IBig(self.0.clone().with_sign(Sign::Positive))
    }
}

impl UnsignedAbs for IBig {
    type Output = UBig;

    #[inline]
    fn unsigned_abs(self) -> UBig {
        UBig(self.0.with_sign(Sign::Positive))
    }
}

impl UnsignedAbs for &IBig {
    type Output = UBig;

    #[inline]
    fn unsigned_abs(self) -> UBig {
        UBig(self.0.clone().with_sign(Sign::Positive))
    }
}

impl Mul<Sign> for UBig {
    type Output = IBig;

    #[inline]
    fn mul(self, rhs: Sign) -> Self::Output {
        IBig(self.0.with_sign(rhs))
    }
}

impl Mul<UBig> for Sign {
    type Output = IBig;

    #[inline]
    fn mul(self, rhs: UBig) -> Self::Output {
        IBig(rhs.0.with_sign(self))
    }
}

impl Mul<Sign> for IBig {
    type Output = IBig;

    #[inline]
    fn mul(self, rhs: Sign) -> Self::Output {
        let sign = self.sign() * rhs;
        IBig(self.0.with_sign(sign))
    }
}

impl Mul<IBig> for Sign {
    type Output = IBig;

    #[inline]
    fn mul(self, rhs: IBig) -> Self::Output {
        let sign = self * rhs.sign();
        IBig(rhs.0.with_sign(sign))
    }
}

impl MulAssign<Sign> for IBig {
    #[inline]
    fn mul_assign(&mut self, rhs: Sign) {
        *self = core::mem::take(self) * rhs;
    }
}

impl Signed for IBig {
    #[inline]
    fn sign(&self) -> Sign {
        self.0.sign()
    }
}