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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
use awint_internals::*;
use const_fn::const_fn;
use crate::Bits;
/// # Summation
impl Bits {
/// Increment-assigns `self` with a carry-in `cin` and returns the carry-out
/// bit. If `cin == true` then one is added to `self`, otherwise nothing
/// happens. `false` is always returned unless `self.is_umax()`.
#[const_fn(cfg(feature = "const_support"))]
pub const fn inc_(&mut self, cin: bool) -> bool {
if !cin {
return false
}
unsafe_for_each_mut!(
self,
x,
{0..(self.total_digits() - 1)}
{
match x.overflowing_add(1) {
(v, false) => {
*x = v;
return false;
}
// if the bits were relatively random, this should rarely happen
(v, true) => {
*x = v;
}
}
},
false
);
let (last, oflow) = self.last().overflowing_add(1);
if self.extra() == 0 {
*self.last_mut() = last;
oflow
} else {
let mask = MAX << self.extra();
let oflow = (last & mask) != 0;
*self.last_mut() = last & (!mask);
oflow
}
}
/// Decrement-assigns `self` with a carry-in `cin` and returns the carry-out
/// bit. If `cin == false` then one is subtracted from `self`, otherwise
/// nothing happens. `true` is always returned unless `self.is_zero()`.
#[const_fn(cfg(feature = "const_support"))]
pub const fn dec_(&mut self, cin: bool) -> bool {
if cin {
return true
}
unsafe_for_each_mut!(
self,
x,
{0..(self.total_digits() - 1)}
{
match x.overflowing_sub(1) {
(v, false) => {
*x = v;
return true
}
(v, true) => {
*x = v;
}
}
},
true
);
if self.extra() == 0 {
let (last, oflow) = self.last().overflowing_add(!0);
*self.last_mut() = last;
oflow
} else {
let mask = MAX << self.extra();
let last = self.last().wrapping_add(!mask);
*self.last_mut() = last & (!mask);
(last & mask) != 0
}
}
/// Negate-assigns `self` if `neg` is true. Note that signed minimum values
/// will overflow.
#[const_fn(cfg(feature = "const_support"))]
pub const fn neg_(&mut self, neg: bool) {
if neg {
self.not_();
// note: do not return overflow from the increment because it only happens if
// `self.is_zero()`, not `self.is_imin()` which will certainly lead
// to accidents
self.inc_(true);
}
}
/// Absolute-value-assigns `self`. Note that signed minimum values will
/// overflow, unless `self` is interpreted as unsigned after a call to this
/// function.
#[const_fn(cfg(feature = "const_support"))]
pub const fn abs_(&mut self) {
self.neg_(self.msb());
}
/// Add-assigns by `rhs`
#[const_fn(cfg(feature = "const_support"))]
#[must_use]
pub const fn add_(&mut self, rhs: &Self) -> Option<()> {
let mut carry = 0;
unsafe_binop_for_each_mut!(
self,
rhs,
x,
y,
{
let tmp = widen_add(*x, y, carry);
*x = tmp.0;
carry = tmp.1;
},
true
)
}
/// Subtract-assigns by `rhs`
#[const_fn(cfg(feature = "const_support"))]
#[must_use]
pub const fn sub_(&mut self, rhs: &Self) -> Option<()> {
let mut carry = 1;
unsafe_binop_for_each_mut!(
self,
rhs,
x,
y,
{
let tmp = widen_add(*x, !y, carry);
*x = tmp.0;
carry = tmp.1;
},
true
)
}
/// Reverse-subtract-assigns by `rhs`. Sets `self` to `(-self) + rhs`.
#[const_fn(cfg(feature = "const_support"))]
#[must_use]
pub const fn rsb_(&mut self, rhs: &Self) -> Option<()> {
let mut carry = 1;
unsafe_binop_for_each_mut!(
self,
rhs,
x,
y,
{
let tmp = widen_add(!*x, y, carry);
*x = tmp.0;
carry = tmp.1;
},
true
)
}
/// Negate-add-assigns by `rhs`. Negates conditionally on `neg`.
#[const_fn(cfg(feature = "const_support"))]
#[must_use]
pub const fn neg_add_(&mut self, neg: bool, rhs: &Self) -> Option<()> {
if neg {
self.sub_(rhs)
} else {
self.add_(rhs)
}
}
/// A general summation with carry-in `cin` and two inputs `lhs` and `rhs`.
/// `self` is set to the sum. The unsigned overflow (equivalent to the
/// carry-out bit) and the signed overflow is returned as a tuple. `None` is
/// returned if any bitwidths do not match. If subtraction is desired,
/// one of the operands can be negated.
#[const_fn(cfg(feature = "const_support"))]
#[must_use]
pub const fn cin_sum_(&mut self, cin: bool, lhs: &Self, rhs: &Self) -> Option<(bool, bool)> {
if self.bw() != lhs.bw() || self.bw() != rhs.bw() {
return None
}
let mut carry = cin as Digit;
unsafe {
const_for!(i in {0..(self.total_digits() - 1)} {
let tmp = widen_add(lhs.get_unchecked(i), rhs.get_unchecked(i), carry);
*self.get_unchecked_mut(i) = tmp.0;
carry = tmp.1;
});
}
let tmp = widen_add(lhs.last(), rhs.last(), carry);
let extra = self.extra();
Some(if extra == 0 {
let lhs_sign = (lhs.last() as IDigit) < 0;
let rhs_sign = (rhs.last() as IDigit) < 0;
let output_sign = (tmp.0 as IDigit) < 0;
*self.last_mut() = tmp.0;
(
tmp.1 != 0,
// Signed overflow only happens if the two input signs are the same and the output
// sign is different
(lhs_sign == rhs_sign) && (output_sign != lhs_sign),
)
} else {
let lhs_sign = (lhs.last() & (1 << (extra - 1))) != 0;
let rhs_sign = (rhs.last() & (1 << (extra - 1))) != 0;
let output_sign = (tmp.0 & (1 << (extra - 1))) != 0;
let mask = MAX << extra;
// handle clearing of unused bits
*self.last_mut() = tmp.0 & (!mask);
(
(tmp.0 & mask) != 0,
(lhs_sign == rhs_sign) && (output_sign != lhs_sign),
)
})
}
}