From f9d9f8b764a703768ac976b749d29f356f36d57e Mon Sep 17 00:00:00 2001 From: github-actions Date: Tue, 20 Feb 2024 01:26:26 +0000 Subject: [PATCH] Update documentation --- bi_8hpp_source.html | 775 +++++--------- bi__exceptions_8hpp_source.html | 62 +- classbi_1_1bi__t.html | 52 +- classbi_1_1division__by__zero-members.html | 2 +- classbi_1_1division__by__zero.html | 7 +- classbi_1_1exception-members.html | 2 +- classbi_1_1exception.html | 7 +- classbi_1_1overflow__error-members.html | 2 +- classbi_1_1overflow__error.html | 7 +- complexity.html | 38 +- dir_68267d1309a1af8e8297ef4c3efbcdba.html | 6 + doxygen_crawl.html | 2 +- h___8hpp_source.html | 1098 ++++++++++++++++++++ menudata.js | 4 +- 14 files changed, 1428 insertions(+), 636 deletions(-) create mode 100644 h___8hpp_source.html diff --git a/bi_8hpp_source.html b/bi_8hpp_source.html index bdc8529..74e9ad7 100644 --- a/bi_8hpp_source.html +++ b/bi_8hpp_source.html @@ -101,556 +101,263 @@
8
9#include <algorithm>
10#include <cassert>
-
11#include <compare>
-
12#include <iostream>
-
13#include <limits>
+
11#include <climits>
+
12#include <compare>
+
13#include <iostream>
14#include <span>
15#include <string>
16#include <utility>
17
-
18#include "bi_config.hpp"
-
19#include "bi_digit_vector.hpp"
-
20
-
21// TODO: modularize through the use of more files and separate implementation
-
22// from interface.
+
18#include "bi_digit_vector.impl.hpp"
+
19
+
20// NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+
21static_assert(sizeof(double) * CHAR_BIT == 64, "64-bit double is assumed.");
+
22static_assert(-1 == ~0, "Two's complement representation assumed.");
23
-
24namespace bi {
-
25
-
26using bi_config::bi_base;
-
27using bi_config::bi_bitcount_t;
-
28using bi_config::bi_dbits;
-
29using bi_config::bi_dmax;
-
30using bi_config::bi_dwidth;
-
31using bi_config::dbl_max_int;
-
32using bi_config::ddigit;
-
33using bi_config::digit;
-
34
-
-
80class BI_API bi_t {
-
81 public:
-
82 // Constructors
-
83 bi_t() noexcept;
-
84 template <std::integral T>
-
85 bi_t(T); // NOLINT(runtime/explicit)
-
86 bi_t(const bi_t&);
-
87 bi_t(bi_t&& other) noexcept;
-
88 explicit bi_t(const std::string&);
-
89 explicit bi_t(const char*);
+
24#if defined(_WIN32)
+
25#if defined(BI_API_EXPORTS)
+
26#define BI_API __declspec(dllexport)
+
27#else
+
28#define BI_API __declspec(dllimport)
+
29#endif
+
30#else
+
31#define BI_API
+
32#endif
+
33
+
34#if defined(BI_FORCE_64_BIT) && defined(__SIZEOF_INT128__)
+
35#define BI_DIGIT_64_BIT
+
36#elif defined(BI_FORCE_32_BIT)
+
37#define BI_DIGIT_32_BIT
+
38#else
+
39#define BI_DIGIT_32_BIT
+
40#endif
+
41
+
42namespace bi {
+
43
+
44#if defined(BI_DIGIT_64_BIT)
+
45using digit = uint64_t;
+
46#else
+
47using digit = uint32_t;
+
48#endif
+
49
+
50using bi_bitcount_t = unsigned long;
+
51using dvector = digit_vector<digit, bi_bitcount_t>;
+
52
+
+
53class BI_API bi_t {
+
54 public:
+
55 // Constructors
+
56 bi_t() noexcept;
+
57 template <std::integral T>
+
58 bi_t(T); // NOLINT(runtime/explicit)
+
59 bi_t(const bi_t&);
+
60 bi_t(bi_t&& other) noexcept;
+
61 explicit bi_t(const std::string&);
+
62 explicit bi_t(const char*);
+
63
+
64 ~bi_t() = default;
+
65
+
66 // Assignment operators
+
67 bi_t& operator=(const bi_t&);
+
68 bi_t& operator=(bi_t&& other) noexcept;
+
69 template <std::integral T>
+
70 bi_t& operator=(T);
+
71
+
72 // Unary operators
+
73 bi_t operator+() const;
+
74 bi_t operator-() const;
+
75
+
76 // Increment and decrement
+
77 bi_t& operator++();
+
78 bi_t operator++(int);
+
79 bi_t& operator--();
+
80 bi_t operator--(int);
+
81
+
82 // Multiplicative operators
+
83 bi_t operator*(const bi_t&) const;
+
84 bi_t operator/(const bi_t&) const;
+
85 bi_t operator%(const bi_t&) const;
+
86 bi_t& operator*=(const bi_t&);
+
87 bi_t& operator/=(const bi_t&);
+
88 bi_t& operator%=(const bi_t&);
+
89 std::pair<bi_t, bi_t> div(const bi_t&) const;
90
-
91 ~bi_t() = default;
-
92
-
93 // Assignment operators
-
94 bi_t& operator=(const bi_t&);
-
95 bi_t& operator=(bi_t&& other) noexcept;
-
96 template <std::integral T>
-
97 bi_t& operator=(T);
-
98
-
99 // Unary operators
-
100 bi_t operator+() const;
-
101 bi_t operator-() const;
+
91 // Additive operators
+
92 bi_t operator+(const bi_t&) const;
+
93 bi_t operator-(const bi_t&) const;
+
94 bi_t& operator+=(const bi_t&);
+
95 bi_t& operator-=(const bi_t&);
+
96
+
97 // Shift operators
+
98 bi_t operator<<(bi_bitcount_t shift) const;
+
99 bi_t operator>>(bi_bitcount_t shift) const;
+
100 bi_t& operator<<=(bi_bitcount_t shift);
+
101 bi_t& operator>>=(bi_bitcount_t shift);
102
-
103 // Increment and decrement
-
104 bi_t& operator++();
-
105 bi_t operator++(int);
-
106 bi_t& operator--();
-
107 bi_t operator--(int);
-
108
-
109 // Multiplicative operators
-
110 bi_t operator*(const bi_t&) const;
-
111 bi_t operator/(const bi_t&) const;
-
112 bi_t operator%(const bi_t&) const;
-
113 bi_t& operator*=(const bi_t&);
-
114 bi_t& operator/=(const bi_t&);
-
115 bi_t& operator%=(const bi_t&);
-
116 std::pair<bi_t, bi_t> div(const bi_t&) const;
-
117
-
118 // Additive operators
-
119 bi_t operator+(const bi_t&) const;
-
120 bi_t operator-(const bi_t&) const;
-
121 bi_t& operator+=(const bi_t&);
-
122 bi_t& operator-=(const bi_t&);
-
123
-
124 // Shift operators
-
125 bi_t operator<<(bi_bitcount_t shift) const;
-
126 bi_t operator>>(bi_bitcount_t shift) const;
-
127 bi_t& operator<<=(bi_bitcount_t shift);
-
128 bi_t& operator>>=(bi_bitcount_t shift);
-
129
-
130 // Comparisons
-
131 std::strong_ordering operator<=>(const bi_t&) const noexcept;
-
132 bool operator==(const bi_t&) const noexcept;
-
133 template <std::integral T>
-
134 std::strong_ordering operator<=>(T) const noexcept;
-
135 template <std::integral T>
-
136 bool operator==(T) const noexcept;
-
137
-
138 // Bitwise operators
-
139 bi_t operator~() const;
-
140 bi_t operator&(const bi_t&) const;
-
141 bi_t operator|(const bi_t&) const;
-
142 bi_t operator^(const bi_t&) const;
-
143 bi_t& operator&=(const bi_t&);
-
144 bi_t& operator|=(const bi_t&);
-
145 bi_t& operator^=(const bi_t&);
-
146
-
147 // Conversion operators
-
148 explicit operator bool() const noexcept;
+
103 // Comparisons
+
104 std::strong_ordering operator<=>(const bi_t&) const noexcept;
+
105 bool operator==(const bi_t&) const noexcept;
+
106 template <std::integral T>
+
107 std::strong_ordering operator<=>(T) const noexcept;
+
108 template <std::integral T>
+
109 bool operator==(T) const noexcept;
+
110
+
111 // Bitwise operators
+
112 bi_t operator~() const;
+
113 bi_t operator&(const bi_t&) const;
+
114 bi_t operator|(const bi_t&) const;
+
115 bi_t operator^(const bi_t&) const;
+
116 bi_t& operator&=(const bi_t&);
+
117 bi_t& operator|=(const bi_t&);
+
118 bi_t& operator^=(const bi_t&);
+
119
+
120 // Conversion operators
+
121 explicit operator bool() const noexcept;
+
122
+
123 // Bits
+
124 bi_bitcount_t bit_length() const noexcept;
+
125 bool test_bit(bi_bitcount_t) const noexcept;
+
126 bi_t& set_bit(bi_bitcount_t);
+
127
+
128 // Accessors for internal representation
+
129 size_t capacity() const noexcept;
+
130 size_t size() const noexcept;
+
131 bool negative() const noexcept;
+
132 std::span<const digit> digits() const;
+
133 void print_internal(std::ostream& os = std::cout) const noexcept;
+
134
+
135 // Other
+
136 void swap(bi_t&) noexcept;
+
137 std::string to_string() const;
+
138 void negate() noexcept;
+
139 int sign() const noexcept;
+
140 bool odd() const noexcept;
+
141 bool even() const noexcept;
+
142
+
143 // Friends
+
144 BI_API friend std::ostream& operator<<(std::ostream& os, const bi_t& x);
+
145
+
146 private:
+
147 dvector vec_;
+
148 bool negative_;
149
-
150 // Bits
-
151 bi_bitcount_t bit_length() const noexcept;
-
152 bool test_bit(bi_bitcount_t) const noexcept;
-
153 bi_t& set_bit(bi_bitcount_t);
-
154
-
155 // Accessors for internal representation
-
156 size_t capacity() const noexcept;
-
157 size_t size() const noexcept;
-
158 bool negative() const noexcept;
-
159 std::span<const digit> digits() const;
-
160 void print_internal(std::ostream& os = std::cout) const noexcept;
-
161
-
162 // Other
-
163 void swap(bi_t&) noexcept;
-
164 std::string to_string() const;
-
165 void negate() noexcept;
-
166 int sign() const noexcept;
-
167 bool odd() const noexcept;
-
168 bool even() const noexcept;
-
169
-
170 // Friends
-
171 BI_API friend std::ostream& operator<<(std::ostream& os, const bi_t& x);
+
150 void reserve_(size_t new_capacity);
+
151 void resize_(size_t new_size);
+
152 digit& operator[](size_t index);
+
153 const digit& operator[](size_t index) const;
+
154 void resize_unsafe_(size_t new_size);
+
155 void trim_trailing_zeros() noexcept;
+
156
+
157 auto begin() noexcept { return vec_.begin(); }
+
158 auto begin() const noexcept { return vec_.begin(); }
+
159 auto end() noexcept { return vec_.end(); }
+
160 auto end() const noexcept { return vec_.end(); }
+
161 auto rbegin() noexcept { return vec_.rbegin(); }
+
162 auto rbegin() const noexcept { return vec_.rbegin(); }
+
163 auto rend() noexcept { return vec_.rend(); }
+
164 auto rend() const noexcept { return vec_.rend(); }
+
165
+
167 friend struct h_;
+
169};
+
+
170
+
171BI_API std::ostream& operator<<(std::ostream&, const bi_t&);
172
-
173 private:
-
174 digit_vector vec_;
-
175 bool negative_;
+
173BI_API void swap(bi_t& a, bi_t& b) noexcept;
+
174BI_API bi_t operator"" _bi(const char* str);
+
175BI_API bi_t abs(const bi_t& value);
176
-
177 // vector modifiers
-
178 void reserve_(size_t new_capacity);
-
179 void resize_(size_t new_size);
-
180 digit& operator[](size_t index);
-
181 const digit& operator[](size_t index) const;
-
182 void resize_unsafe_(size_t new_size);
-
183 void trim_trailing_zeros() noexcept;
+
181
+
183inline size_t bi_t::capacity() const noexcept { return vec_.capacity(); }
184
-
185 // vector iterators
-
186 auto begin() noexcept { return vec_.begin(); }
-
187 auto begin() const noexcept { return vec_.begin(); }
-
188 auto end() noexcept { return vec_.end(); }
-
189 auto end() const noexcept { return vec_.end(); }
-
190 auto rbegin() noexcept { return vec_.rbegin(); }
-
191 auto rbegin() const noexcept { return vec_.rbegin(); }
-
192 auto rend() noexcept { return vec_.rend(); }
-
193 auto rend() const noexcept { return vec_.rend(); }
-
194
-
195 // comparisons
-
196 static int cmp_abs(const bi_t&, const bi_t&) noexcept;
-
197 static int cmp(const bi_t&, const bi_t&) noexcept;
-
198 template <std::integral T>
-
199 static int cmp(const bi_t&, T) noexcept;
-
200
-
201 // initializing
-
202 template <std::integral T>
-
203 static void init_one_digit(bi_t&, T);
-
204 template <std::integral T>
-
205 static void init_atleast_one_digit(bi_t&, T);
-
206 void init_string(const std::string& str);
-
207
-
208 // arithmetic
-
209 static void sub_abs_gt(bi_t& result, const bi_t& a, const bi_t& b);
-
210 static void add_abs(bi_t& result, const bi_t& a, const bi_t& b);
-
211 static void sub_abs(bi_t& result, const bi_t& a, const bi_t& b);
-
212 static void add(bi_t& result, const bi_t& a, const bi_t& b);
-
213 static void sub(bi_t& result, const bi_t& a, const bi_t& b);
-
214 static void mul(bi_t& result, const bi_t& a, const bi_t& b);
-
215 void imul1add1(digit v, digit k);
-
216 static void left_shift(bi_t& result, const bi_t& a, bi_bitcount_t shift);
-
217 static void right_shift(bi_t& result, const bi_t& a, bi_bitcount_t shift);
-
218 static void div_algo_binary(bi_t& q, bi_t& r, const bi_t& n, const bi_t& d);
-
219 static void div_algo_single(bi_t& q, bi_t& r, const bi_t& n,
-
220 const bi_t& d) noexcept;
-
221 static void div_algo_knuth(bi_t& q, bi_t& r, const bi_t& n, const bi_t& d);
-
222 static void divide(bi_t& q, bi_t& r, const bi_t& n, const bi_t& d);
-
223
-
224 enum class BitwiseOperation { AND, OR, XOR };
-
225 template <BitwiseOperation Op>
-
226 static void bitwise_operation_impl(bi_t& res, const bi_t& a, const bi_t& b);
-
227 template <BitwiseOperation Op>
-
228 static bi_t bitwise_operation(const bi_t& a, const bi_t& b);
-
229 template <BitwiseOperation Op>
-
230 bi_t& ibitwise_operation(const bi_t& other);
-
231
-
232 // increment/decrement helpers
-
233 void increment_abs();
-
234 void decrement_abs();
-
235
-
236 // to_string() helpers
-
237 uint8_t idiv10() noexcept;
-
238 size_t decimal_length() const;
-
239
-
240 // misc.
-
241 template <DigitIterator InputIterator>
-
242 bi_t(InputIterator first, InputIterator last, bool negative = false);
-
243};
-
-
244
-
245BI_API std::ostream& operator<<(std::ostream&, const bi_t&);
-
246
-
247BI_API void swap(bi_t& a, bi_t& b) noexcept;
-
248BI_API bi_t operator"" _bi(const char* str);
-
249BI_API bi_t abs(const bi_t& value);
-
250
-
255
-
257inline size_t bi_t::capacity() const noexcept { return vec_.capacity(); }
-
258
-
260inline size_t bi_t::size() const noexcept { return vec_.size(); }
-
261
-
-
270inline std::span<const digit> bi_t::digits() const {
-
271 if (vec_.size() == 0) {
-
272 return std::span<const digit>();
-
273 }
-
274 return std::span<const digit>(vec_.data(), vec_.size());
-
275}
+
186inline size_t bi_t::size() const noexcept { return vec_.size(); }
+
187
+
189inline bool bi_t::negative() const noexcept { return negative_; }
+
190
+
+
199inline std::span<const digit> bi_t::digits() const {
+
200 if (vec_.size() == 0) {
+
201 return std::span<const digit>();
+
202 }
+
203 return std::span<const digit>(vec_.data(), vec_.size());
+
204}
-
276
-
278inline bool bi_t::negative() const noexcept { return negative_; }
-
279
-
281
-
286
-
287inline void bi_t::reserve_(size_t new_capacity) { vec_.reserve(new_capacity); }
-
288
-
289inline void bi_t::resize_(size_t new_size) { vec_.resize(new_size); }
-
290
-
291inline digit& bi_t::operator[](size_t index) { return vec_[index]; }
-
292
-
293inline const digit& bi_t::operator[](size_t index) const { return vec_[index]; }
-
294
-
295inline void bi_t::resize_unsafe_(size_t new_size) {
-
296 assert(new_size <= vec_.capacity());
-
297 vec_.resize_unsafe(new_size);
-
298}
-
299
-
300inline void bi_t::trim_trailing_zeros() noexcept {
-
301 size_t new_size = vec_.size();
-
302 while (new_size > 0 && vec_[new_size - 1] == 0) {
-
303 --new_size;
-
304 }
-
305 vec_.resize(new_size);
-
306 if (new_size == 0) {
-
307 negative_ = false;
-
308 }
-
309}
-
310
-
312
-
313template <std::integral T>
-
314void bi_t::init_one_digit(bi_t& x, T value) {
-
315 x.resize_(1);
-
316
-
317 if (value >= 0) {
-
318 x[0] = static_cast<digit>(value);
-
319 x.negative_ = false;
-
320 } else {
-
321 x[0] = static_cast<digit>(0) - static_cast<digit>(value);
-
322 x.negative_ = true;
-
323 }
-
324}
-
325
-
326template <std::integral T>
-
327void bi_t::init_atleast_one_digit(bi_t& x, T value) {
-
328 using UnsignedT = typename std::make_unsigned<T>::type;
-
329
-
330 size_t size = 1;
-
331 UnsignedT temp, uvalue;
-
332
-
333 if (value >= 0) {
-
334 uvalue = value;
-
335 x.negative_ = false;
-
336 } else {
-
337 uvalue = static_cast<UnsignedT>(0) - static_cast<UnsignedT>(value);
-
338 x.negative_ = true;
-
339 }
-
340
-
341 temp = uvalue;
-
342
-
343 while (temp >>= bi_dwidth) {
-
344 ++size;
-
345 }
-
346
-
347 x.resize_(size);
-
348
-
349 for (size_t i = 0; uvalue != 0; ++i) {
-
350 x[i] = static_cast<digit>(uvalue);
-
351 uvalue >>= bi_dwidth;
-
352 }
-
353}
-
354
-
358template <std::integral T>
-
-
359bi_t::bi_t(T value) {
-
360 using UnsignedT = typename std::make_unsigned<T>::type;
-
361
-
362 if (value == 0) {
-
363 vec_ = digit_vector();
-
364 negative_ = false;
-
365 return;
-
366 }
-
367
-
368 if constexpr (std::numeric_limits<T>::max() <= bi_dmax) {
-
369 bi_t::init_one_digit(*this, value);
-
370 } else {
-
371 bi_t::init_atleast_one_digit(*this, value);
-
372 }
-
373}
-
-
374
-
380template <DigitIterator InputIterator>
-
381bi_t::bi_t(InputIterator first, InputIterator last, bool negative)
-
382 : vec_(first, last), negative_(negative) {
-
383 trim_trailing_zeros();
-
384}
-
385
-
390
-
394template <std::integral T>
-
-
395bi_t& bi_t::operator=(T value) {
-
396 using UnsignedT = typename std::make_unsigned<T>::type;
-
397
-
398 UnsignedT uvalue;
-
399 if (value == 0) {
-
400 resize_(0);
-
401 negative_ = false;
-
402 return *this;
-
403 } else if (value < 0) {
-
404 uvalue = static_cast<UnsignedT>(0) - static_cast<UnsignedT>(value);
-
405 negative_ = true;
-
406 } else {
-
407 uvalue = value;
-
408 negative_ = false;
-
409 }
-
410
-
411 if constexpr (std::numeric_limits<T>::max() <= bi_dmax) {
-
412 resize_(1);
-
413 vec_[0] = static_cast<digit>(uvalue);
-
414 } else {
-
415 UnsignedT temp = uvalue;
-
416
-
417 size_t n_digits = 1;
-
418 while (temp >>= bi_dwidth) {
-
419 ++n_digits;
-
420 }
-
421
-
422 resize_(n_digits);
-
423 for (size_t i = 0; uvalue != 0; ++i) {
-
424 vec_[i] = static_cast<digit>(uvalue);
-
425 uvalue >>= bi_dwidth;
-
426 }
-
427 }
-
428
-
429 return *this;
-
430}
-
-
431
-
433
-
434template <std::integral T>
-
435int bi_t::cmp(const bi_t& a, T b) noexcept {
-
436 if (b == 0) {
-
437 if (a.size() == 0) {
-
438 return 0; // a
-
439 }
-
440 return a.negative() ? -1 : 1; // b
-
441 }
-
442
-
443 using UnsignedT = typename std::make_unsigned<T>::type;
-
444 const bool b_negative = b < 0;
-
445 const UnsignedT unsigned_b =
-
446 b_negative ? -static_cast<UnsignedT>(b) : static_cast<UnsignedT>(b);
-
447
-
448 if (a.negative() && !b_negative) {
-
449 return -1; // c
-
450 }
-
451 if (!a.negative() && b_negative) {
-
452 return 1; // d
-
453 }
-
454
-
455 size_t n_b_digits = 0;
-
456 if constexpr (std::numeric_limits<UnsignedT>::max() <= bi_dmax) {
-
457 n_b_digits = (unsigned_b != 0) ? 1 : 0;
-
458 } else {
-
459 UnsignedT temp_b = unsigned_b;
-
460 while (temp_b != 0) {
-
461 temp_b >>= bi_dwidth;
-
462 n_b_digits++;
-
463 }
-
464 }
-
465
-
466 const size_t a_size = a.size();
-
467 if (a_size < n_b_digits) {
-
468 return a.negative() ? 1 : -1; // e
-
469 }
-
470
-
471 if (a_size > n_b_digits) {
-
472 return a.negative() ? -1 : 1; // f
-
473 }
-
474
-
475 for (size_t i = n_b_digits; i-- > 0;) {
-
476 const digit a_digit = a[i];
-
477 const digit b_digit = static_cast<digit>(unsigned_b >> (bi_dwidth * i));
-
478
-
479 if (a_digit < b_digit) {
-
480 return a.negative() ? 1 : -1; // g
-
481 }
-
482 if (a_digit > b_digit) {
-
483 return a.negative() ? -1 : 1; // h
-
484 }
-
485 }
-
486 return 0; // i
-
487}
-
488
-
496
-
497template <std::integral T>
-
498std::strong_ordering bi_t::operator<=>(T rhs) const noexcept {
-
499 return bi_t::cmp(*this, rhs) <=> 0;
-
500}
-
501
-
502template <std::integral T>
-
503bool bi_t::operator==(T rhs) const noexcept {
-
504 return bi_t::cmp(*this, rhs) == 0;
-
505}
-
506
-
508
-
513
-
-
518inline void bi_t::swap(bi_t& other) noexcept {
-
519 using std::swap;
-
520 swap(this->vec_, other.vec_);
-
521 swap(this->negative_, other.negative_);
-
522}
+
205
+
207
+
212
+
213inline void bi_t::reserve_(size_t new_capacity) { vec_.reserve(new_capacity); }
+
214
+
215inline void bi_t::resize_(size_t new_size) { vec_.resize(new_size); }
+
216
+
217inline digit& bi_t::operator[](size_t index) { return vec_[index]; }
+
218
+
219inline const digit& bi_t::operator[](size_t index) const { return vec_[index]; }
+
220
+
221inline void bi_t::resize_unsafe_(size_t new_size) {
+
222 assert(new_size <= vec_.capacity());
+
223 vec_.resize_unsafe(new_size);
+
224}
+
225
+
226inline void bi_t::trim_trailing_zeros() noexcept {
+
227 size_t new_size = vec_.size();
+
228 while (new_size > 0 && vec_[new_size - 1] == 0) {
+
229 --new_size;
+
230 }
+
231 vec_.resize(new_size);
+
232 if (new_size == 0) {
+
233 negative_ = false;
+
234 }
+
235}
+
236
+
238
+
243
+
+
248inline void bi_t::swap(bi_t& other) noexcept {
+
249 using std::swap;
+
250 swap(this->vec_, other.vec_);
+
251 swap(this->negative_, other.negative_);
+
252}
-
523
-
-
529inline int bi_t::sign() const noexcept {
-
530 if (size() == 0) {
-
531 return 0;
-
532 }
-
533 return negative_ ? -1 : 1;
-
534}
+
253
+
+
258inline void bi_t::negate() noexcept {
+
259 if (size() != 0) {
+
260 negative_ = !negative_;
+
261 }
+
262}
-
535
-
-
540inline void bi_t::negate() noexcept {
-
541 if (size() != 0) {
-
542 negative_ = !negative_;
-
543 }
-
544}
+
263
+
+
269inline int bi_t::sign() const noexcept {
+
270 if (size() == 0) {
+
271 return 0;
+
272 }
+
273 return negative_ ? -1 : 1;
+
274}
-
545
-
-
550inline bool bi_t::odd() const noexcept {
-
551 return size() == 0 ? false : (*this)[0] & 1;
-
552}
+
275
+
+
280inline bool bi_t::odd() const noexcept {
+
281 return size() == 0 ? false : (*this)[0] & 1;
+
282}
-
553
-
558inline bool bi_t::even() const noexcept { return !odd(); }
-
559
-
561
-
563inline digit_vector to_twos_complement(const digit_vector& vec) {
-
564 const size_t vec_size = vec.size();
-
565 digit_vector result;
-
566 result.resize(vec_size);
-
567
-
568 bool carry = true;
-
569 for (size_t i = 0; i < vec_size; ++i) {
-
570 const digit sum = ~vec[i] + carry;
-
571 carry = sum < static_cast<uint8_t>(carry);
-
572 result[i] = sum;
-
573 }
-
574
-
575 return result;
-
576}
-
577
-
579inline void to_twos_complement_in_place(digit_vector& vec) noexcept {
-
580 const size_t vec_size = vec.size();
-
581
-
582 bool carry = true;
-
583 for (size_t i = 0; i < vec_size; ++i) {
-
584 const digit sum = ~vec[i] + carry;
-
585 carry = sum < static_cast<uint8_t>(carry);
-
586 vec[i] = sum;
-
587 }
-
588}
-
589
-
591template <bi_t::BitwiseOperation Op>
-
592void bi_t::bitwise_operation_impl(bi_t& result, const bi_t& x, const bi_t& y) {
-
593 size_t max_size = std::max(x.size(), y.size());
-
594
-
595 const digit_vector& lhs_digits =
-
596 x.negative_ ? to_twos_complement(x.vec_) : x.vec_;
-
597 const digit_vector& rhs_digits =
-
598 y.negative_ ? to_twos_complement(y.vec_) : y.vec_;
-
599
-
600 bool result_negative; // NOLINT(cppcoreguidelines-init-variables)
-
601 if constexpr (Op == BitwiseOperation::AND) {
-
602 result_negative = x.negative_ && y.negative_;
-
603 } else if constexpr (Op == BitwiseOperation::OR) {
-
604 result_negative = x.negative_ || y.negative_;
-
605 } else if constexpr (Op == BitwiseOperation::XOR) {
-
606 result_negative = x.negative_ != y.negative_;
-
607 ++max_size;
-
608 }
-
609
-
610 result.resize_(max_size);
-
611
-
612 for (size_t i = 0; i < result.size(); ++i) {
-
613 const digit lhs_digit =
-
614 i < lhs_digits.size() ? lhs_digits[i] : (x.negative_ ? bi_dmax : 0);
-
615 const digit rhs_digit =
-
616 i < rhs_digits.size() ? rhs_digits[i] : (y.negative_ ? bi_dmax : 0);
-
617
-
618 if constexpr (Op == BitwiseOperation::AND) {
-
619 result[i] = lhs_digit & rhs_digit;
-
620 } else if constexpr (Op == BitwiseOperation::OR) {
-
621 result[i] = lhs_digit | rhs_digit;
-
622 } else if constexpr (Op == BitwiseOperation::XOR) {
-
623 result[i] = lhs_digit ^ rhs_digit;
-
624 }
-
625 }
-
626
-
627 result.negative_ = result_negative;
-
628
-
629 if (result.negative_) {
-
630 to_twos_complement_in_place(result.vec_);
-
631 }
-
632
-
633 result.trim_trailing_zeros();
-
634}
-
635
-
637template <bi_t::BitwiseOperation Op>
-
638bi_t bi_t::bitwise_operation(const bi_t& a, const bi_t& b) {
-
639 bi_t result;
-
640 bitwise_operation_impl<Op>(result, a, b);
-
641 return result;
-
642}
-
643
-
645template <bi_t::BitwiseOperation Op>
-
646bi_t& bi_t::ibitwise_operation(const bi_t& other) {
-
647 bitwise_operation_impl<Op>(*this, *this, other);
-
648 return *this;
-
649}
-
650
-
651} // namespace bi
-
652
-
653#endif // BI_INCLUDE_BI_HPP_
-
bi::bi_t
Arbitrary-precision integer type and related functions.
Definition bi.hpp:80
-
bi::bi_t::bi_t
bi_t() noexcept
Default constructor. The integer is initialized to zero and no memory allocation occurs.
Definition bi.cpp:31
-
bi::bi_t::sign
int sign() const noexcept
Return an int indicating the sign of the number: -1 for negative, 0 for zero, 1 for positive.
Definition bi.hpp:529
-
bi::bi_t::capacity
size_t capacity() const noexcept
Return the number of digits the allocated storage can hold.
Definition bi.hpp:257
-
bi::bi_t::size
size_t size() const noexcept
Return the number of digits used. Instance represents 0 iff size() == 0.
Definition bi.hpp:260
-
bi::bi_t::negate
void negate() noexcept
Negates the integer in place.
Definition bi.hpp:540
-
bi::bi_t::swap
void swap(bi_t &) noexcept
Swap the contents of this bi_t object with another bi_t object.
Definition bi.hpp:518
-
bi::bi_t::odd
bool odd() const noexcept
Return true if this integer is odd, false otherwise.
Definition bi.hpp:550
-
bi::bi_t::digits
std::span< const digit > digits() const
Return a read-only span of the digits stored in the internal digit vector, with least significant dig...
Definition bi.hpp:270
-
bi::bi_t::operator=
bi_t & operator=(const bi_t &)
Copy assignment operator.
Definition bi.cpp:92
-
bi::bi_t::negative
bool negative() const noexcept
Reture true if the integer is (strictly) negative, false otherwise.
Definition bi.hpp:278
-
bi::bi_t::even
bool even() const noexcept
Return true if this integer is even, false otherwise.
Definition bi.hpp:558
+
283
+
288inline bool bi_t::even() const noexcept { return !odd(); }
+
289
+
291
+
292} // namespace bi
+
293
+
294#endif // BI_INCLUDE_BI_HPP_
+
bi::bi_t
Arbitrary-precision integer type and related functions.
Definition bi.hpp:53
+
bi::bi_t::sign
int sign() const noexcept
Return an int indicating the sign of the number: -1 for negative, 0 for zero, 1 for positive.
Definition bi.hpp:269
+
bi::bi_t::capacity
size_t capacity() const noexcept
Return the number of digits the allocated storage can hold.
Definition bi.hpp:183
+
bi::bi_t::size
size_t size() const noexcept
Return the number of digits used. Instance represents 0 iff size() == 0.
Definition bi.hpp:186
+
bi::bi_t::negate
void negate() noexcept
Negates the integer in place.
Definition bi.hpp:258
+
bi::bi_t::swap
void swap(bi_t &) noexcept
Swap the contents of this bi_t object with another bi_t object.
Definition bi.hpp:248
+
bi::bi_t::odd
bool odd() const noexcept
Return true if this integer is odd, false otherwise.
Definition bi.hpp:280
+
bi::bi_t::digits
std::span< const digit > digits() const
Return a read-only span of the digits stored in the internal digit vector, with least significant dig...
Definition bi.hpp:199
+
bi::bi_t::negative
bool negative() const noexcept
Reture true if the integer is (strictly) negative, false otherwise.
Definition bi.hpp:189
+
bi::bi_t::even
bool even() const noexcept
Return true if this integer is even, false otherwise.
Definition bi.hpp:288
diff --git a/bi__exceptions_8hpp_source.html b/bi__exceptions_8hpp_source.html index e1a726f..1479854 100644 --- a/bi__exceptions_8hpp_source.html +++ b/bi__exceptions_8hpp_source.html @@ -108,42 +108,38 @@
15
16namespace bi {
17
-
-
25class exception : public std::runtime_error {
-
26 public:
-
27#ifdef __cpp_lib_source_location
-
28 exception(const std::string& message, const std::source_location& location =
-
29 std::source_location::current())
-
30 : std::runtime_error(message + "Thrown at " + location.file_name() + ":" +
-
31 std::to_string(location.line()) + " in function " +
-
32 location.function_name()) {}
-
33#else
-
34 explicit exception(const std::string& message)
-
35 : std::runtime_error(message) {}
-
36#endif
-
37};
+
+
18class exception : public std::runtime_error {
+
19 public:
+
20#ifdef __cpp_lib_source_location
+
21 exception(const std::string& message, const std::source_location& location =
+
22 std::source_location::current());
+
23#else
+
24 explicit exception(const std::string& message);
+
25#endif
+
26};
-
38
-
-
44class overflow_error : public exception {
-
45 public:
-
46 using exception::exception;
-
47};
+
27
+
+
28class overflow_error : public exception {
+
29 public:
+
30 using exception::exception;
+
31};
-
48
-
-
52class division_by_zero : public exception {
-
53 public:
-
54 using exception::exception;
-
55};
+
32
+
+
33class division_by_zero : public exception {
+
34 public:
+
35 using exception::exception;
+
36};
-
56
-
57} // namespace bi
-
58
-
59#endif // BI_INCLUDE_BI_EXCEPTIONS_HPP_
-
bi::division_by_zero
Throws if a division by zero attempt is detected.
Definition bi_exceptions.hpp:52
-
bi::exception
Base exception class for the bi library.
Definition bi_exceptions.hpp:25
-
bi::overflow_error
Throws if an operation expects the result to require a digit vector with size() exceeding max_size()....
Definition bi_exceptions.hpp:44
+
37
+
38} // namespace bi
+
39
+
40#endif // BI_INCLUDE_BI_EXCEPTIONS_HPP_
+
bi::division_by_zero
Throws if a division by zero attempt is detected.
Definition bi_exceptions.hpp:33
+
bi::exception
Base exception class for the bi library.
Definition bi_exceptions.hpp:18
+
bi::overflow_error
Throws if an operation expects the result to require a digit vector with size() exceeding max_size()....
Definition bi_exceptions.hpp:28
diff --git a/classbi_1_1bi__t.html b/classbi_1_1bi__t.html index e8ebeae..928663a 100644 --- a/classbi_1_1bi__t.html +++ b/classbi_1_1bi__t.html @@ -95,7 +95,7 @@

Arbitrary-precision integer type and related functions. More...

-

#include <bi.hpp>

+

#include "bi.hpp"

@@ -130,8 +130,8 @@
bi_t empty{""}; // Throws std::invalid_argument
bi_t nll{nullptr}; // Throws std::invalid_argument
bi_t invalid{" -"}; // Throws std::invalid_argument
-
bi::bi_t
Arbitrary-precision integer type and related functions.
Definition bi.hpp:80
-
bi::bi_t::bi_t
bi_t() noexcept
Default constructor. The integer is initialized to zero and no memory allocation occurs.
Definition bi.cpp:31
+
bi::bi_t
Arbitrary-precision integer type and related functions.
Definition bi.hpp:53
+
bi::bi_t::bi_t
bi_t() noexcept
Default constructor. The integer is initialized to zero and no memory allocation occurs.
Definition bi.cpp:74
@@ -363,7 +363,7 @@

The custom exception classes derive from std::runtime_error. To catch and handle these specific exceptions, #include the "bi_exceptions.hpp" header (in addition to "bi.hpp").

Internals

-

The representation of a bi_t consists of a digit vector and a boolean indicating if the integer is negative. The integer is represented internally as a base \( 2^{n} \) integer where \( n \) is typically 32 bits. An element of the digit vector, i.e. a digit, is typically a uint32_t. The digit vector stores the magnitude of the integer, with least significant digits first. Counts of bits are represented by the bi_bitcount_t type, which is an unsigned long. Counts of bytes for dynamically allocated memory expects a size_t type. Thus, the digit vector is theoretically constrained to be less than or equal to SIZE_MAX / bi_sizeof_digit, where bi_sizeof_digit represents the number of bytes in a digit (typically 4). Additionally, because counts of bits use the unsigned long type, we also constrain the maximum size of the vector to be less than or equal to ULONG_MAX / bi_dbits, where bi_dbits is the number of bits in the digit data type (typically 32). Together, these constraints determine max_size() for the internal digit vector. An operation that expects a result to exceed max_size() throws bi::overflow_error.

+

The representation of a bi_t consists of a digit vector and a boolean indicating if the integer is negative. The integer is represented internally as a base \( 2^{n} \) integer where \( n \) is typically 32 bits. An element of the digit vector, i.e. a digit, is typically a uint32_t. The digit vector stores the magnitude of the integer, with least significant digits first. Counts of bits are represented by the bi_bitcount_t type, which is an unsigned long. Counts of bytes for dynamically allocated memory expects a size_t type. Thus, the digit vector is theoretically constrained to be less than or equal to SIZE_MAX / sizeof(digit). Additionally, because counts of bits use the unsigned long type, we also constrain the maximum size of the vector to be less than or equal to ULONG_MAX / (CHAR_BIT * sizeof(digit)), where the denominator is the number of bits in the digit data type (typically 32). Together, these constraints determine max_size() for the internal digit vector. An operation that expects a result to exceed max_size() throws bi::overflow_error.

Constructor & Destructor Documentation

◆ bi_t()

@@ -389,7 +389,7 @@

Default constructor. The integer is initialized to zero and no memory allocation occurs.

-
Complexity
O(1)
+
Complexity
O(1)
@@ -445,7 +445,7 @@

Returns
A pair of bi_t objects where the first element is the quotient and the second element is the remainder.
-
Complexity
\( O(m \cdot n) \) where \( m \) is the size() of the dividend and \( n \) is the size() of the divisor.
+
Complexity
\( O(m \cdot n) \) where \( m \) is the size() of the dividend and \( n \) is the size() of the divisor.
@@ -473,7 +473,7 @@

Return true if this integer is even, false otherwise.

-
Complexity
O(1)
+
Complexity
O(1)
@@ -501,7 +501,7 @@

Negates the integer in place.

-
Complexity
O(1)
+
Complexity
O(1)
@@ -529,7 +529,7 @@

Return true if this integer is odd, false otherwise.

-
Complexity
O(1)
+
Complexity
O(1)
@@ -564,7 +564,7 @@

std::cout << "x is zero!" << std::endl;
}

The output is

x is zero!
-
Complexity
O(1)
+
Complexity
O(1)
@@ -582,7 +582,7 @@

-
Complexity
\( O(m \cdot n) \)
+
Complexity
\( O(m \cdot n) \)
@@ -600,7 +600,7 @@

-
Complexity
\( O(m \cdot n) \)
+
Complexity
\( O(m \cdot n) \)
@@ -641,7 +641,7 @@

-
Complexity
\( O(m \cdot n) \)
+
Complexity
\( O(m \cdot n) \)
@@ -659,7 +659,7 @@

-
Complexity
\( O(m \cdot n) \)
+
Complexity
\( O(m \cdot n) \)
@@ -677,7 +677,7 @@

-
Complexity
\( O(n) \)
+
Complexity
\( O(n) \)
@@ -695,7 +695,7 @@

-
Complexity
\( O(n) \)
+
Complexity
\( O(n) \)
@@ -713,7 +713,7 @@

-
Complexity
\( O(n) \)
+
Complexity
\( O(n) \)
@@ -731,7 +731,7 @@

-
Complexity
\( O(n) \)
+
Complexity
\( O(n) \)
@@ -749,7 +749,7 @@

-
Complexity
\( O(m \cdot n) \)
+
Complexity
\( O(m \cdot n) \)
@@ -767,7 +767,7 @@

-
Complexity
\( O(m \cdot n) \)
+
Complexity
\( O(m \cdot n) \)
@@ -929,7 +929,7 @@

Return an int indicating the sign of the number: -1 for negative, 0 for zero, 1 for positive.

-
Complexity
O(1)
+
Complexity
O(1)
@@ -957,7 +957,7 @@

Swap the contents of this bi_t object with another bi_t object.

-
Complexity
O(1)
+
Complexity
O(1)
@@ -983,7 +983,7 @@

s = x.to_string(); // s == "65535"
x = -32768;
s = x.to_string(); // s == "-32768"
-
bi::bi_t::to_string
std::string to_string() const
Return a string containing the base-10 (decimal) representation of the integer.
Definition bi.cpp:743
+
bi::bi_t::to_string
std::string to_string() const
Return a string containing the base-10 (decimal) representation of the integer.
Definition bi.cpp:688
@@ -1086,14 +1086,10 @@

Swap the contents of a with b.

-
Complexity
O(1)
+
Complexity
O(1)
-
The documentation for this class was generated from the following files:
    -
  • include/bi.hpp
    • -
  • src/bi.cpp
    • -
diff --git a/classbi_1_1division__by__zero-members.html b/classbi_1_1division__by__zero-members.html index e769c1b..a42116c 100644 --- a/classbi_1_1division__by__zero-members.html +++ b/classbi_1_1division__by__zero-members.html @@ -89,7 +89,7 @@

This is the complete list of members for bi::division_by_zero, including all inherited members.

Public Member Functions

 bi_t (const std::string &)
- +
exception(const std::string &message) (defined in bi::division_by_zero)bi::division_by_zeroinlineexplicit
exception(const std::string &message) (defined in bi::division_by_zero)bi::division_by_zeroexplicit
diff --git a/classbi_1_1division__by__zero.html b/classbi_1_1division__by__zero.html index 919ad8d..938ce07 100644 --- a/classbi_1_1division__by__zero.html +++ b/classbi_1_1division__by__zero.html @@ -93,7 +93,7 @@

Throws if a division by zero attempt is detected. More...

-

#include <bi_exceptions.hpp>

+

#include "bi_exceptions.hpp"

Inheritance diagram for bi::division_by_zero:
@@ -116,10 +116,7 @@

Detailed Description

Throws if a division by zero attempt is detected.

-
The documentation for this class was generated from the following file: -
+
Generated by doxygen 1.10.0 diff --git a/classbi_1_1exception-members.html b/classbi_1_1exception-members.html index 056420c..10c5d73 100644 --- a/classbi_1_1exception-members.html +++ b/classbi_1_1exception-members.html @@ -89,7 +89,7 @@

This is the complete list of members for bi::exception, including all inherited members.

- +
exception(const std::string &message) (defined in bi::exception)bi::exceptioninlineexplicit
exception(const std::string &message) (defined in bi::exception)bi::exceptionexplicit
diff --git a/classbi_1_1exception.html b/classbi_1_1exception.html index 20eb3ca..9817bfd 100644 --- a/classbi_1_1exception.html +++ b/classbi_1_1exception.html @@ -93,7 +93,7 @@

Base exception class for the bi library. More...

-

#include <bi_exceptions.hpp>

+

#include "bi_exceptions.hpp"

Inheritance diagram for bi::exception:
@@ -114,10 +114,7 @@

Detailed Description

Base exception class for the bi library.

This class serves as the root for all exception types specific to the bi library, providing a common base from which all other custom exceptions derive. It extends std::runtime_error.

-
The documentation for this class was generated from the following file: -
+
Generated by doxygen 1.10.0 diff --git a/classbi_1_1overflow__error-members.html b/classbi_1_1overflow__error-members.html index 79b9cc0..f53560e 100644 --- a/classbi_1_1overflow__error-members.html +++ b/classbi_1_1overflow__error-members.html @@ -89,7 +89,7 @@

This is the complete list of members for bi::overflow_error, including all inherited members.

- +
exception(const std::string &message) (defined in bi::overflow_error)bi::overflow_errorinlineexplicit
exception(const std::string &message) (defined in bi::overflow_error)bi::overflow_errorexplicit
diff --git a/classbi_1_1overflow__error.html b/classbi_1_1overflow__error.html index 2f55e0b..9616ec4 100644 --- a/classbi_1_1overflow__error.html +++ b/classbi_1_1overflow__error.html @@ -93,7 +93,7 @@

Throws if an operation expects the result to require a digit vector with size() exceeding max_size(). See the internals section. More...

-

#include <bi_exceptions.hpp>

+

#include "bi_exceptions.hpp"

Inheritance diagram for bi::overflow_error:
@@ -116,10 +116,7 @@

Detailed Description

Throws if an operation expects the result to require a digit vector with size() exceeding max_size(). See the internals section.

-
The documentation for this class was generated from the following file: -
+
Generated by doxygen 1.10.0 diff --git a/complexity.html b/complexity.html index 7cbf82e..1cef0fb 100644 --- a/complexity.html +++ b/complexity.html @@ -84,43 +84,43 @@
Member bi::bi_t::bi_t () noexcept
-
O(1)
+
O(1)
Member bi::bi_t::div (const bi_t &) const
-
\( O(m \cdot n) \) where \( m \) is the size() of the dividend and \( n \) is the size() of the divisor.
+
\( O(m \cdot n) \) where \( m \) is the size() of the dividend and \( n \) is the size() of the divisor.
Member bi::bi_t::even () const noexcept
-
O(1)
+
O(1)
Member bi::bi_t::negate () noexcept
-
O(1)
+
O(1)
Member bi::bi_t::odd () const noexcept
-
O(1)
+
O(1)
Member bi::bi_t::operator bool () const noexcept
-
O(1)
+
O(1)
Member bi::bi_t::operator% (const bi_t &) const
-
\( O(m \cdot n) \)
+
\( O(m \cdot n) \)
Member bi::bi_t::operator%= (const bi_t &)
-
\( O(m \cdot n) \)
+
\( O(m \cdot n) \)
Member bi::bi_t::operator* (const bi_t &) const
-
\( O(m \cdot n) \)
+
\( O(m \cdot n) \)
Member bi::bi_t::operator*= (const bi_t &)
-
\( O(m \cdot n) \)
+
\( O(m \cdot n) \)
Member bi::bi_t::operator+ (const bi_t &) const
-
\( O(n) \)
+
\( O(n) \)
Member bi::bi_t::operator+= (const bi_t &)
-
\( O(n) \)
+
\( O(n) \)
Member bi::bi_t::operator- (const bi_t &) const
-
\( O(n) \)
+
\( O(n) \)
Member bi::bi_t::operator-= (const bi_t &)
-
\( O(n) \)
+
\( O(n) \)
Member bi::bi_t::operator/ (const bi_t &) const
-
\( O(m \cdot n) \)
+
\( O(m \cdot n) \)
Member bi::bi_t::operator/= (const bi_t &)
-
\( O(m \cdot n) \)
+
\( O(m \cdot n) \)
Member bi::bi_t::sign () const noexcept
-
O(1)
+
O(1)
Member bi::bi_t::swap (bi_t &) noexcept
-
O(1)
+
O(1)
Member swap
-
O(1)
+
O(1)
diff --git a/dir_68267d1309a1af8e8297ef4c3efbcdba.html b/dir_68267d1309a1af8e8297ef4c3efbcdba.html index 2646683..e2cd7ed 100644 --- a/dir_68267d1309a1af8e8297ef4c3efbcdba.html +++ b/dir_68267d1309a1af8e8297ef4c3efbcdba.html @@ -86,6 +86,12 @@
src Directory Reference
+ + + + +

+Files

 h_.hpp
 
diff --git a/doxygen_crawl.html b/doxygen_crawl.html index e9d8e5e..b4455aa 100644 --- a/doxygen_crawl.html +++ b/doxygen_crawl.html @@ -10,6 +10,7 @@ + @@ -50,6 +51,5 @@ - diff --git a/h___8hpp_source.html b/h___8hpp_source.html new file mode 100644 index 0000000..9a1a2d6 --- /dev/null +++ b/h___8hpp_source.html @@ -0,0 +1,1098 @@ + + + + + + + +bi: src/h_.hpp Source File + + + + + + + + + + + + + + +
+
h_.hpp
+
+
+
1/*
+
2Copyright 2024 Owain Davies
+
3SPDX-License-Identifier: Apache-2.0
+
4*/
+
5
+
6#ifndef BI_SRC_H__HPP_
+
7#define BI_SRC_H__HPP_
+
8
+
9#include <algorithm>
+
10#include <array>
+
11#include <cassert>
+
12#include <cmath>
+
13#include <limits>
+
14#include <string>
+
15#include <utility>
+
16
+
17#include "bi.hpp"
+
18#include "bi_exceptions.hpp"
+
19#include "constants.hpp"
+
20#include "uints.hpp"
+
21
+
23
+
24namespace bi {
+
25
+
27struct h_ {
+
28 // increment/decrement
+
29 static void increment_abs(bi_t& x);
+
30 static void decrement_abs(bi_t& x);
+
31
+
32 // additive
+
33 static void add_abs(bi_t& result, const bi_t& a, const bi_t& b);
+
34 static void add(bi_t& result, const bi_t& a, const bi_t& b);
+
35 static void sub_abs_gt(bi_t& result, const bi_t& a, const bi_t& b);
+
36 static void sub_abs(bi_t& result, const bi_t& a, const bi_t& b);
+
37 static void sub(bi_t& result, const bi_t& a, const bi_t& b);
+
38
+
39 // multiplicative
+
40 static void imul1add1(bi_t& x, digit v, digit k);
+
41 static void mul(bi_t& result, const bi_t& a, const bi_t& b);
+
42 static void div_algo_single(bi_t& q, bi_t& r, const bi_t& n,
+
43 const bi_t& d) noexcept;
+
44 static void div_algo_binary(bi_t& q, bi_t& r, const bi_t& n, const bi_t& d);
+
45 static void div_algo_knuth(bi_t& q, bi_t& r, const bi_t& n, const bi_t& d);
+
46 static void divide(bi_t& q, bi_t& r, const bi_t& n, const bi_t& d);
+
47
+
48 // bits
+
49 static void left_shift(bi_t& result, const bi_t& a, bi_bitcount_t shift);
+
50 static void right_shift(bi_t& result, const bi_t& a, bi_bitcount_t shift);
+
51 enum class BitwiseOperation { AND, OR, XOR };
+
52 template <BitwiseOperation Op>
+
53 static void bitwise_operation_impl(bi_t& res, const bi_t& a, const bi_t& b);
+
54 template <BitwiseOperation Op>
+
55 static bi_t bitwise_operation(const bi_t& a, const bi_t& b);
+
56 template <BitwiseOperation Op>
+
57 static bi_t& ibitwise_operation(bi_t&, const bi_t& other);
+
58
+
59 // comparisons
+
60 static int cmp_abs(const bi_t&, const bi_t&) noexcept;
+
61 static int cmp(const bi_t&, const bi_t&) noexcept;
+
62 template <std::integral T>
+
63 static int cmp(const bi_t& a, T b) noexcept;
+
64
+
65 // to_string()
+
66 static uint8_t idiv10(bi_t& x) noexcept;
+
67 static size_t decimal_length(const bi_t& x);
+
68
+
69 // initializing
+
70 template <std::integral T>
+
71 static void init_one_digit(bi_t& x, T value);
+
72 template <std::integral T>
+
73 static void init_atleast_one_digit(bi_t& x, T value);
+
74 static void init_string(bi_t& x, const std::string& str);
+
75
+
76 // misc.
+
77 static dvector to_twos_complement(const dvector& vec);
+
78 static void to_twos_complement_in_place(dvector& vec) noexcept;
+
79};
+
80
+
81void h_::increment_abs(bi_t& x) {
+
82 if (x.size() == 0 || x[x.size() - 1] == std::numeric_limits<digit>::max()) {
+
83 x.reserve_(x.size() + 1);
+
84 }
+
85
+
86 if (x.size() == 0) {
+
87 x.resize_(1);
+
88 x[0] = 1;
+
89 return;
+
90 }
+
91
+
92 size_t i = 0;
+
93 bool carry = true;
+
94
+
95 while (carry && i < x.size()) {
+
96 if (x[i] == std::numeric_limits<digit>::max()) {
+
97 x[i] = 0;
+
98 } else {
+
99 ++x[i];
+
100 carry = false;
+
101 }
+
102 ++i;
+
103 }
+
104
+
105 if (carry) {
+
106 x.vec_.push_back(1);
+
107 }
+
108}
+
109
+
110void h_::decrement_abs(bi_t& x) {
+
111 if (x.size() == 0) {
+
112 x.resize_(1);
+
113 x[0] = 1;
+
114 x.negative_ = true;
+
115 return;
+
116 }
+
117
+
118 size_t i = 0;
+
119 bool borrow = true;
+
120
+
121 while (borrow && i < x.size()) {
+
122 if (x[i] == 0) {
+
123 // Borrow from the next more significant digit
+
124 x[i] = std::numeric_limits<digit>::max();
+
125 } else {
+
126 --x[i];
+
127 borrow = false;
+
128 }
+
129 ++i;
+
130 }
+
131
+
132 x.trim_trailing_zeros();
+
133}
+
134
+
197
+
199void h_::add_abs(bi_t& r, const bi_t& x, const bi_t& y) {
+
200 // Algorithm assumes x.size() >= y.size()
+
201 const bi_t& large = x.size() >= y.size() ? x : y;
+
202 const bi_t& small = x.size() >= y.size() ? y : x;
+
203
+
204 r.reserve_(large.size() + 1);
+
205
+
206 digit temp{};
+
207 bool carry = 0;
+
208 size_t i = 0;
+
209 for (; i < small.size(); ++i) {
+
210 uints::uaddc(temp, large[i], small[i], carry);
+
211 r[i] = temp;
+
212 }
+
213
+
214 while (i < large.size()) {
+
215 temp = large[i] + carry;
+
216 carry = temp < static_cast<uint8_t>(carry); // MSVC warning C4804
+
217 r[i++] = temp;
+
218 }
+
219
+
220 r[i] = carry;
+
221 r.resize_(large.size() + 1);
+
222 r.trim_trailing_zeros();
+
223 r.negative_ = false;
+
224}
+
225
+
227void h_::add(bi_t& r, const bi_t& x, const bi_t& y) {
+
228 if (x.negative()) {
+
229 if (y.negative()) {
+
230 // x < 0, y < 0 ==> x = -|x|, y = -|y|. ==> x + y = -(|x| + |y|)
+
231 add_abs(r, x, y);
+
232 r.negative_ = true;
+
233 } else {
+
234 // x < 0, y >= 0 ==> x = -|x|, y = |y| ==> x + y = |y| - |x|
+
235 sub_abs(r, y, x);
+
236 }
+
237 } else {
+
238 if (y.negative()) {
+
239 // x >= 0, y < 0 ==> x = |x|, y = -|y| ==> x + y = |x| - |y|
+
240 sub_abs(r, x, y);
+
241 } else {
+
242 // x >= 0, y >= 0 ==> x = |x|, y = |y| ==> x + y = |x| + |y|
+
243 add_abs(r, x, y);
+
244 }
+
245 }
+
246}
+
247
+
249void h_::sub_abs_gt(bi_t& r, const bi_t& x, const bi_t& y) {
+
250 assert(x.size() >= y.size());
+
251
+
252 r.reserve_(x.size());
+
253
+
254 digit temp{};
+
255 bool borrow = 0;
+
256 size_t i = 0;
+
257 for (; i < y.size(); ++i) {
+
258 uints::usubb(temp, x[i], y[i], borrow);
+
259 r[i] = temp;
+
260 }
+
261 while (i < x.size()) {
+
262 temp = x[i] - borrow;
+
263 borrow = temp > x[i];
+
264 r[i++] = temp;
+
265 }
+
266
+
267 r.resize_(x.size());
+
268 r.trim_trailing_zeros();
+
269 r.negative_ = false;
+
270}
+
271
+
273void h_::sub_abs(bi_t& r, const bi_t& x, const bi_t& y) {
+
274 if (x.size() == y.size()) {
+
275 const auto [it_x, it_y] = std::mismatch(x.rbegin(), x.rend(), y.rbegin());
+
276
+
277 if (it_x == x.rend()) {
+
278 // x, y have the same digits (or both are zero)
+
279 r.resize_(0);
+
280 r.negative_ = false;
+
281 return;
+
282 }
+
283
+
284 if (*it_y > *it_x) {
+
285 sub_abs_gt(r, y, x);
+
286 r.negative_ = true;
+
287 } else {
+
288 sub_abs_gt(r, x, y);
+
289 }
+
290 } else if (x.size() > y.size()) {
+
291 sub_abs_gt(r, x, y);
+
292 } else {
+
293 sub_abs_gt(r, y, x);
+
294 r.negative_ = true;
+
295 }
+
296}
+
297
+
299void h_::sub(bi_t& r, const bi_t& x, const bi_t& y) {
+
300 if (x.negative()) {
+
301 if (y.negative()) {
+
302 // x < 0, y < 0 ==> x = -|x|, y = -|y| ==> x - y = |y| - |x|
+
303 sub_abs(r, y, x);
+
304 } else {
+
305 // x < 0, y >= 0 ==> x = -|x|, y = |y| ==> x - y = -(|x| + |y|)
+
306 add_abs(r, x, y);
+
307 r.negative_ = true;
+
308 }
+
309 } else {
+
310 if (y.negative()) {
+
311 // x >= 0, y < 0 ==> x = |x|, y = -|y| ==> x - y = |x| + |y|
+
312 add_abs(r, x, y);
+
313 } else {
+
314 // x >= 0, y >= 0 ==> x = |x|, y = |y| ==> x - y = |x| - |y|
+
315 sub_abs(r, x, y);
+
316 }
+
317 }
+
318}
+
319
+
321
+
367inline void h_::imul1add1(bi_t& x, digit v, digit k = 0) {
+
368 for (auto& d : x.vec_) {
+
369 const ddigit t = static_cast<ddigit>(d) * v + k;
+
370 k = t >> bi_dwidth; // floor(t / 2^{bi_dwidth})
+
371 d = static_cast<digit>(t); // t mod 2^{bi_dwidth}
+
372 }
+
373
+
374 if (k) {
+
375 x.vec_.push_back(k);
+
376 }
+
377}
+
378
+
385void h_::mul(bi_t& result, const bi_t& a, const bi_t& b) {
+
386 if (a.size() == 0 || b.size() == 0) {
+
387 result.resize_(0);
+
388 result.negative_ = false;
+
389 return;
+
390 }
+
391
+
392 const size_t m = a.size();
+
393 const size_t n = b.size();
+
394
+
395 const auto [n_result_digits, overflow] = uints::uadd_overflow(m, n);
+
396 if (overflow) {
+
397 throw overflow_error("");
+
398 }
+
399
+
400 const bool overlap = &result == &a || &result == &b;
+
401
+
402 bi_t temp;
+
403 bi_t& target = overlap ? temp : result;
+
404
+
405 target.resize_(n_result_digits);
+
406
+
407 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+
408 std::fill(target.begin(), target.begin() + m, 0);
+
409
+
410 for (size_t j = 0; j < n; ++j) {
+
411 digit k = 0;
+
412 for (size_t i = 0; i < m; ++i) {
+
413 const ddigit t = static_cast<ddigit>(a[i]) * b[j] +
+
414 static_cast<ddigit>(target[i + j]) + k;
+
415 k = t >> bi_dwidth; // floor(t / 2^{bi_dwidth})
+
416 target[i + j] = static_cast<digit>(t); // t mod 2^{bi_dwidth}
+
417 }
+
418 target[j + m] = k;
+
419 }
+
420
+
421 target.trim_trailing_zeros();
+
422 target.negative_ = a.negative() != b.negative();
+
423
+
424 if (overlap) {
+
425 result.swap(target);
+
426 }
+
427}
+
428
+
459void h_::div_algo_single(bi_t& q, bi_t& r, const bi_t& u,
+
460 const bi_t& v) noexcept {
+
461 ddigit rem{0};
+
462
+
463 for (size_t j = u.size() - 1; j < std::numeric_limits<size_t>::max(); --j) {
+
464 const ddigit temp = (rem << bi_dwidth) | u[j]; // rem * bi_base + u[j]
+
465 q[j] = temp / v[0];
+
466 rem = temp % v[0];
+
467 }
+
468
+
469 r[0] = static_cast<digit>(rem);
+
470
+
471 q.trim_trailing_zeros();
+
472 r.trim_trailing_zeros();
+
473}
+
474
+
502void h_::div_algo_binary(bi_t& q, bi_t& r, const bi_t& u, const bi_t& v) {
+
503 // (2)
+
504 q = 0;
+
505 r = 0;
+
506
+
507 // (3)
+
508 for (unsigned long i = u.bit_length() - 1; i < ULONG_MAX; --i) {
+
509 // (3)(I)
+
510 r <<= 1;
+
511
+
512 // (3)(II)
+
513 if (u.test_bit(i)) {
+
514 r.set_bit(0);
+
515 }
+
516
+
517 // (3)(III)
+
518 if (h_::cmp_abs(r, v) >= 0) {
+
519 // (3)(III)(a)
+
520 h_::sub_abs(r, r, v);
+
521 // (3)(III)(b)
+
522 q.set_bit(i);
+
523 }
+
524 }
+
525}
+
526
+
589void h_::div_algo_knuth(bi_t& q, bi_t& r, const bi_t& u, const bi_t& v) {
+
590#if defined(BI_DIGIT_64_BIT)
+
591 using sddigit = __int128;
+
592#else
+
593 using sddigit = int64_t;
+
594#endif
+
595
+
596 const size_t m = u.size();
+
597 const size_t n = v.size();
+
598
+
599 /* (1) Normalize */
+
600 // Find e such that b > 2^{e} * v_{n-1} >= b / 2
+
601 constexpr digit b_half = bi_base >> 1;
+
602 const digit v_msd = v[n - 1];
+
603 int e = 0;
+
604 while ((v_msd << e) < b_half) {
+
605 ++e;
+
606 }
+
607 const int compl_e = bi_dwidth - e;
+
608
+
609 bi_t u_norm, v_norm;
+
610 u_norm.resize_(m + 1);
+
611 v_norm.resize_(n);
+
612
+
613 // u_norm set to u * 2^{e}. Cast to ddigit as e may be 0 which would be UB
+
614 u_norm[0] = u[0] << e;
+
615 for (size_t i = 1; i < m; ++i) {
+
616 u_norm[i] = (u[i] << e) | (static_cast<ddigit>(u[i - 1]) >> compl_e);
+
617 }
+
618 u_norm[m] = static_cast<ddigit>(u[m - 1]) >> compl_e;
+
619
+
620 // v_norm set to v * 2^{e}
+
621 v_norm[0] = v[0] << e;
+
622 for (size_t i = 1; i < n; ++i) {
+
623 v_norm[i] = (v[i] << e) | (static_cast<ddigit>(v[i - 1]) >> compl_e);
+
624 }
+
625
+
626 const digit vp = v_norm[n - 1], vpp = v_norm[n - 2];
+
627 /* (2) Initialize j. Also (7) Loop on j */
+
628 for (size_t j = m - n; j < std::numeric_limits<size_t>::max(); --j) {
+
629 /* (3) Calculate q_hat */
+
630 const ddigit tmp = u_norm[j + n] * bi_base + u_norm[j + n - 1];
+
631 ddigit q_hat = tmp / vp;
+
632 ddigit r_hat = tmp % vp;
+
633
+
634 while (q_hat == bi_base ||
+
635 q_hat * vpp > bi_base * r_hat + u_norm[j + n - 2]) {
+
636 --q_hat;
+
637 r_hat += vp;
+
638 if (r_hat >= bi_base)
+
639 break;
+
640 }
+
641
+
642 /* (4) Multiply and subtract */
+
643 sddigit b{};
+
644 for (size_t i = 0; i < n; ++i) {
+
645 const ddigit product = q_hat * v_norm[i];
+
646 const sddigit stmp =
+
647 static_cast<sddigit>(u_norm[j + i]) - static_cast<digit>(product) - b;
+
648 u_norm[j + i] = static_cast<digit>(stmp);
+
649 b = static_cast<sddigit>(product >> bi_dbits) - (stmp >> bi_dbits);
+
650 }
+
651 const bool neg{u_norm[j + n] < b};
+
652 u_norm[j + n] = static_cast<digit>(u_norm[j + n] - b);
+
653
+
654 /* (5) Test remainder */
+
655 q[j] = q_hat;
+
656
+
657 if (neg) {
+
658 /* (6) Add back */
+
659 // Decrease q_{j} by 1
+
660 --q[j];
+
661
+
662 // Add (0v_{n-1}...v_{0})_{b} to (u_{j+n}...u_{j})_{b}
+
663 digit c = 0;
+
664 for (size_t i = 0; i < n; ++i) {
+
665 const ddigit tmp = (static_cast<ddigit>(u_norm[j + i]) + v_norm[i]) + c;
+
666 u_norm[j + i] = tmp;
+
667 c = tmp >> bi_dwidth;
+
668 }
+
669 // A carry will occur to the left of u_{j+n} and it should be ignored
+
670 u_norm[j + n] += c;
+
671 assert(u_norm[j + n] == 0);
+
672 }
+
673 }
+
674
+
675 /* (8) Unnormalize */
+
676 // (u_{n-1}...u_{0})_{b} / 2^e
+
677 const size_t last_idx = n - 1;
+
678 r[last_idx] = u_norm[last_idx] >> e;
+
679 for (size_t i = last_idx; i-- > 0;) {
+
680 r[i] = (static_cast<ddigit>(u_norm[i + 1]) << compl_e) | (u_norm[i] >> e);
+
681 }
+
682
+
683 q.trim_trailing_zeros();
+
684 r.trim_trailing_zeros();
+
685}
+
686
+
700void h_::divide(bi_t& Q, bi_t& R, const bi_t& N, const bi_t& D) {
+
701 if (D.size() == 0) {
+
702 throw division_by_zero("Division by zero attempt.");
+
703 }
+
704
+
705 const size_t size_N = N.size();
+
706 const size_t size_D = D.size();
+
707
+
708 // |N| < |D| case
+
709 if ((size_N == size_D && N[size_N - 1] < D[size_D - 1]) || size_N < size_D) {
+
710 Q = 0; // |N| < |D| ==> |N| / |D| < 1 ==> Q computes to 0
+
711 R = N; // Computation (a/b)*b + a%b should equal a ==> a%b is a
+
712 return;
+
713 }
+
714
+
715 // TRUE: size_N >= size_D > 0
+
716
+
717 // Ensure enough space in Q and R
+
718 const size_t size_Q = size_N - size_D + 1;
+
719 Q.resize_(size_Q);
+
720 R.resize_(size_D);
+
721
+
722 // Unsigned integer division algorithms
+
723 if (size_D == 1) {
+
724 // Knuth (Vol. 2, 4.3.1, p. 272) recommends using the algorithm used in
+
725 // div_algo_single() when size_D is 1.
+
726 div_algo_single(Q, R, N, D);
+
727 } else {
+
728 div_algo_knuth(Q, R, N, D);
+
729 }
+
730
+
731 Q.negative_ = D.negative() ^ N.negative();
+
732 R.negative_ = R.size() > 0 && N.negative();
+
733}
+
734
+
741
+
748void h_::left_shift(bi_t& result, const bi_t& x, bi_bitcount_t n_bits) {
+
749 if (x.size() == 0) {
+
750 result.resize_unsafe_(0);
+
751 result.negative_ = false;
+
752 return;
+
753 }
+
754
+
755 if (n_bits == 0) {
+
756 result = x; // Copy assignment avoids copying if &result == &x
+
757 return;
+
758 }
+
759
+
760 const size_t size_x = x.size();
+
761 const bi_bitcount_t digit_shift = n_bits / bi_dwidth;
+
762 const unsigned bit_shift = n_bits % bi_dwidth;
+
763
+
764 const size_t size_result = size_x + digit_shift + (bit_shift ? 1 : 0);
+
765 if (size_result < size_x) {
+
766 throw overflow_error("Result size exceeds SIZE_MAX.");
+
767 }
+
768
+
769 // Create a temporary vector if `result` and `x` overlap
+
770 dvector temp_vec;
+
771 dvector& target_vec = (&result == &x) ? temp_vec : result.vec_;
+
772
+
773 target_vec.resize(size_result);
+
774
+
775 size_t i = 0;
+
776 // Zero-fill vacated digits
+
777 for (; i < digit_shift; ++i) {
+
778 target_vec[i] = 0;
+
779 }
+
780
+
781 const auto compl_bit_shift = bi_dwidth - bit_shift;
+
782
+
783 digit carry = 0;
+
784 for (size_t j = 0; j < size_x; ++j, ++i) {
+
785 const digit current = x[j];
+
786 target_vec[i] = (current << bit_shift) | carry;
+
787 carry = bit_shift ? (current >> compl_bit_shift) : 0;
+
788 }
+
789
+
790 if (bit_shift) {
+
791 target_vec[i] = carry;
+
792 }
+
793
+
794 if (&result == &x) {
+
795 result.vec_ = std::move(temp_vec);
+
796 }
+
797
+
798 result.trim_trailing_zeros();
+
799 result.negative_ = x.negative();
+
800}
+
801
+
810void h_::right_shift(bi_t& result, const bi_t& x, bi_bitcount_t n_bits) {
+
811 // TODO: maybe set `result = x` for special cases x.size() == 0 || n_bits == 0
+
812 const size_t size_x = x.size();
+
813
+
814 const bi_bitcount_t digit_shift = n_bits / bi_dwidth;
+
815 const unsigned bit_shift = n_bits % bi_dwidth;
+
816
+
817 if (size_x <= digit_shift) {
+
818 if (x.negative()) {
+
819 // Set result to -1
+
820 result.resize_(1);
+
821 result[0] = 1;
+
822 result.negative_ = true;
+
823 } else {
+
824 // Set result to 0
+
825 result.resize_unsafe_(0);
+
826 result.negative_ = false;
+
827 }
+
828 return;
+
829 }
+
830
+
831 result.resize_(size_x - digit_shift);
+
832
+
833 if (bit_shift == 0) {
+
834 for (size_t i = 0; i < result.size(); ++i) {
+
835 result[i] = x[i + digit_shift];
+
836 }
+
837 } else {
+
838 const unsigned compl_bit_shift = bi_dwidth - bit_shift;
+
839
+
840 for (size_t i = 0, k = digit_shift + 1; i < result.size(); ++i, ++k) {
+
841 result[i] = x[k - 1] >> bit_shift;
+
842 if (k < size_x) {
+
843 result[i] |= x[k] << compl_bit_shift;
+
844 }
+
845 }
+
846 }
+
847
+
848 result.trim_trailing_zeros();
+
849 result.negative_ = x.negative();
+
850
+
851 // At this point, the result is trunc(x / 2^{n_bits}) for all x
+
852
+
853 // Adjust for floor division for negative numbers
+
854 if (x.negative()) {
+
855 bool subtract_one = false;
+
856 if (bit_shift > 0) {
+
857 const digit mask = (static_cast<digit>(1) << bit_shift) - 1;
+
858 if ((x[digit_shift] & mask) != 0) {
+
859 subtract_one = true;
+
860 }
+
861 }
+
862 if (!subtract_one && digit_shift > 0) {
+
863 for (size_t i = 0; i < digit_shift; ++i) {
+
864 if (x[i] != 0) {
+
865 subtract_one = true;
+
866 break;
+
867 }
+
868 }
+
869 }
+
870 if (subtract_one) {
+
871 --result;
+
872 }
+
873 }
+
874}
+
875
+
877
+
879template <h_::BitwiseOperation Op>
+
880void h_::bitwise_operation_impl(bi_t& result, const bi_t& x, const bi_t& y) {
+
881 size_t max_size = std::max(x.size(), y.size());
+
882
+
883 const dvector& lhs_digits = x.negative_ ? to_twos_complement(x.vec_) : x.vec_;
+
884 const dvector& rhs_digits = y.negative_ ? to_twos_complement(y.vec_) : y.vec_;
+
885
+
886 bool result_negative; // NOLINT(cppcoreguidelines-init-variables)
+
887 if constexpr (Op == BitwiseOperation::AND) {
+
888 result_negative = x.negative_ && y.negative_;
+
889 } else if constexpr (Op == BitwiseOperation::OR) {
+
890 result_negative = x.negative_ || y.negative_;
+
891 } else if constexpr (Op == BitwiseOperation::XOR) {
+
892 result_negative = x.negative_ != y.negative_;
+
893 ++max_size;
+
894 }
+
895
+
896 result.resize_(max_size);
+
897
+
898 for (size_t i = 0; i < result.size(); ++i) {
+
899 const digit lhs_digit =
+
900 i < lhs_digits.size() ? lhs_digits[i] : (x.negative_ ? bi_dmax : 0);
+
901 const digit rhs_digit =
+
902 i < rhs_digits.size() ? rhs_digits[i] : (y.negative_ ? bi_dmax : 0);
+
903
+
904 if constexpr (Op == BitwiseOperation::AND) {
+
905 result[i] = lhs_digit & rhs_digit;
+
906 } else if constexpr (Op == BitwiseOperation::OR) {
+
907 result[i] = lhs_digit | rhs_digit;
+
908 } else if constexpr (Op == BitwiseOperation::XOR) {
+
909 result[i] = lhs_digit ^ rhs_digit;
+
910 }
+
911 }
+
912
+
913 result.negative_ = result_negative;
+
914
+
915 if (result.negative_) {
+
916 to_twos_complement_in_place(result.vec_);
+
917 }
+
918
+
919 result.trim_trailing_zeros();
+
920}
+
921
+
923template <h_::BitwiseOperation Op>
+
924bi_t h_::bitwise_operation(const bi_t& a, const bi_t& b) {
+
925 bi_t result;
+
926 bitwise_operation_impl<Op>(result, a, b);
+
927 return result;
+
928}
+
929
+
931template <h_::BitwiseOperation Op>
+
932bi_t& h_::ibitwise_operation(bi_t& x, const bi_t& other) {
+
933 bitwise_operation_impl<Op>(x, x, other);
+
934 return x;
+
935}
+
936
+
937// Assumes x, y >= 0
+
938int h_::cmp_abs(const bi_t& x, const bi_t& y) noexcept {
+
939 if (x.size() > y.size()) {
+
940 return 1;
+
941 } else if (x.size() < y.size()) {
+
942 return -1;
+
943 } else {
+
944 for (size_t i = x.size(); i-- > 0;) {
+
945 if (x.vec_[i] > y.vec_[i]) {
+
946 return 1;
+
947 } else if (x.vec_[i] < y.vec_[i]) {
+
948 return -1;
+
949 }
+
950 }
+
951 return 0;
+
952 }
+
953}
+
954
+
956int h_::cmp(const bi_t& x, const bi_t& y) noexcept {
+
957 if (!x.negative() && y.negative()) {
+
958 // x >= 0, y < 0
+
959 return 1;
+
960 } else if (x.negative() && !y.negative()) {
+
961 // x < 0, y >= 0
+
962 return -1;
+
963 } else if (x.negative() && y.negative()) {
+
964 // x, y < 0
+
965 if (x.size() > y.size()) {
+
966 return -1;
+
967 } else if (x.size() < y.size()) {
+
968 return 1;
+
969 } else {
+
970 for (size_t i = x.size(); i-- > 0;) {
+
971 if (x.vec_[i] < y.vec_[i]) {
+
972 return 1;
+
973 } else if (x.vec_[i] > y.vec_[i]) {
+
974 return -1;
+
975 }
+
976 }
+
977 return 0;
+
978 }
+
979 } else {
+
980 // x, y >= 0
+
981 return h_::cmp_abs(x, y);
+
982 }
+
983}
+
984
+
985template <std::integral T>
+
986int h_::cmp(const bi_t& a, T b) noexcept {
+
987 if (b == 0) {
+
988 if (a.size() == 0) {
+
989 return 0; // a
+
990 }
+
991 return a.negative() ? -1 : 1; // b
+
992 }
+
993
+
994 using UnsignedT = typename std::make_unsigned<T>::type;
+
995 const bool b_negative = b < 0;
+
996 const UnsignedT unsigned_b =
+
997 b_negative ? -static_cast<UnsignedT>(b) : static_cast<UnsignedT>(b);
+
998
+
999 if (a.negative() && !b_negative) {
+
1000 return -1; // c
+
1001 }
+
1002 if (!a.negative() && b_negative) {
+
1003 return 1; // d
+
1004 }
+
1005
+
1006 size_t n_b_digits = 0;
+
1007 if constexpr (std::numeric_limits<UnsignedT>::max() <= bi_dmax) {
+
1008 n_b_digits = (unsigned_b != 0) ? 1 : 0;
+
1009 } else {
+
1010 UnsignedT temp_b = unsigned_b;
+
1011 while (temp_b != 0) {
+
1012 temp_b >>= bi_dwidth;
+
1013 n_b_digits++;
+
1014 }
+
1015 }
+
1016
+
1017 const size_t a_size = a.size();
+
1018 if (a_size < n_b_digits) {
+
1019 return a.negative() ? 1 : -1; // e
+
1020 }
+
1021
+
1022 if (a_size > n_b_digits) {
+
1023 return a.negative() ? -1 : 1; // f
+
1024 }
+
1025
+
1026 for (size_t i = n_b_digits; i-- > 0;) {
+
1027 const digit a_digit = a[i];
+
1028 const digit b_digit = static_cast<digit>(unsigned_b >> (bi_dwidth * i));
+
1029
+
1030 if (a_digit < b_digit) {
+
1031 return a.negative() ? 1 : -1; // g
+
1032 }
+
1033 if (a_digit > b_digit) {
+
1034 return a.negative() ? -1 : 1; // h
+
1035 }
+
1036 }
+
1037 return 0; // i
+
1038}
+
1039
+
1044
+
1046uint8_t h_::idiv10(bi_t& x) noexcept {
+
1047 constexpr ddigit base = static_cast<ddigit>(bi_dmax) + 1;
+
1048 uint8_t carry = 0;
+
1049
+
1050 // NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
+
1051 for (size_t i = x.size(); i-- > 0;) {
+
1052 const ddigit current = (base * carry) + x.vec_[i];
+
1053 x.vec_[i] = static_cast<digit>(current / 10);
+
1054 carry = static_cast<uint8_t>(current % 10);
+
1055 }
+
1056 // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
+
1057
+
1058 x.trim_trailing_zeros();
+
1059 return carry;
+
1060}
+
1061
+
1096size_t h_::decimal_length(const bi_t& x) {
+
1097 // TODO: a different exception is probably more appropriate in this func
+
1098 constexpr const char* s = "Decimal digit estimation exceeds practical limit.";
+
1099 constexpr double log10_2 = 0.30103; // log10(2)
+
1100
+
1101 const bi_bitcount_t bitlen = x.bit_length();
+
1102 if (bitlen > dbl_max_int) {
+
1103 throw overflow_error(s);
+
1104 }
+
1105
+
1106 const bi_bitcount_t r = static_cast<bi_bitcount_t>(
+
1107 std::floor(static_cast<double>(bitlen) * log10_2) + 1);
+
1108 if (r > std::numeric_limits<size_t>::max() - 2) {
+
1109 throw overflow_error(s);
+
1110 }
+
1111
+
1112 return r;
+
1113}
+
1114
+
1116
+
1117template <std::integral T>
+
1118void h_::init_one_digit(bi_t& x, T value) {
+
1119 x.resize_(1);
+
1120
+
1121 if (value >= 0) {
+
1122 x[0] = static_cast<digit>(value);
+
1123 x.negative_ = false;
+
1124 } else {
+
1125 x[0] = static_cast<digit>(0) - static_cast<digit>(value);
+
1126 x.negative_ = true;
+
1127 }
+
1128}
+
1129
+
1130template <std::integral T>
+
1131void h_::init_atleast_one_digit(bi_t& x, T value) {
+
1132 using UnsignedT = typename std::make_unsigned<T>::type;
+
1133
+
1134 size_t size = 1;
+
1135 UnsignedT temp, uvalue;
+
1136
+
1137 if (value >= 0) {
+
1138 uvalue = value;
+
1139 x.negative_ = false;
+
1140 } else {
+
1141 uvalue = static_cast<UnsignedT>(0) - static_cast<UnsignedT>(value);
+
1142 x.negative_ = true;
+
1143 }
+
1144
+
1145 temp = uvalue;
+
1146
+
1147 while (temp >>= bi_dwidth) {
+
1148 ++size;
+
1149 }
+
1150
+
1151 x.resize_(size);
+
1152
+
1153 for (size_t i = 0; uvalue != 0; ++i) {
+
1154 x[i] = static_cast<digit>(uvalue);
+
1155 uvalue >>= bi_dwidth;
+
1156 }
+
1157}
+
1158
+
1159// TODO: move this somewhere else.
+
1356
+
1357
+
1358constexpr auto pow2_8 = 1 << 8;
+
1359
+
1360constexpr std::array<uint8_t, pow2_8> create_char_to_b36_map() {
+
1361 // NOLINTBEGIN(cppcoreguidelines-avoid-magic-numbers)
+
1362 constexpr auto n_digits = 10;
+
1363 constexpr auto n_letters = 26;
+
1364 constexpr std::array<char, n_letters> lowercase{
+
1365 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+
1366 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
+
1367 constexpr std::array<char, n_letters> uppercase{
+
1368 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+
1369 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
+
1370
+
1371 std::array<uint8_t, pow2_8> map{};
+
1372 map.fill(0xFF);
+
1373
+
1374 for (uint8_t i = 0; i < n_digits; ++i) {
+
1375 map.at(static_cast<uint8_t>('0') + i) = i;
+
1376 }
+
1377
+
1378 for (uint8_t i = 0; i < n_letters; ++i) {
+
1379 map.at(static_cast<uint8_t>(lowercase.at(i))) = 10 + i;
+
1380 map.at(static_cast<uint8_t>(uppercase.at(i))) = 10 + i;
+
1381 }
+
1382
+
1383 return map;
+
1384 // NOLINTEND(cppcoreguidelines-avoid-magic-numbers)
+
1385}
+
1386
+
1387constexpr auto char_to_int_map = create_char_to_b36_map();
+
1388
+
1389constexpr uint8_t char_to_b36(char ch) {
+
1390 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
+
1391 return char_to_int_map[static_cast<uint8_t>(ch)];
+
1392}
+
1393
+
1394// Calculate 10 ** n
+
1395constexpr digit pow10(size_t n) {
+
1396 digit result = 1;
+
1397 for (size_t i = 0; i < n; ++i) {
+
1398 // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+
1399 result *= 10;
+
1400 }
+
1401 return result;
+
1402}
+
1403
+
1404// Generate an array of powers of ten
+
1405template <size_t... Indices>
+
1406constexpr auto make_powers_of_ten(std::index_sequence<Indices...>) {
+
1407 return std::array<digit, sizeof...(Indices)>{pow10(Indices)...};
+
1408}
+
1409
+
1410// If digit <==> uint32_t (uint64_t), 10^{9} (10^{19}) is the highest power of
+
1411// 10 that fits in it.
+
1412constexpr int max_batch_size = (bi_dwidth == 64) ? 19 : 9;
+
1413
+
1414constexpr auto powers_of_ten =
+
1415 make_powers_of_ten(std::make_index_sequence<max_batch_size + 1>{});
+
1416
+
1417void h_::init_string(bi_t& x, const std::string& s) {
+
1418 // std::stoi and company allow leading whitespace and a plus/minus sign. We
+
1419 // follow suit.
+
1420
+
1421 // Allow leading whitespace
+
1422 auto it = std::find_if_not(s.begin(), s.end(),
+
1423 [](char ch) { return std::isspace(ch); });
+
1424
+
1425 // Allow plus/minus sign to precede first decimal digit
+
1426 x.negative_ = false;
+
1427 if (it != s.end()) {
+
1428 if (*it == '-') {
+
1429 x.negative_ = true;
+
1430 ++it;
+
1431 } else if (*it == '+') {
+
1432 ++it;
+
1433 }
+
1434 }
+
1435
+
1436 const auto start_digit = it;
+
1437 it = std::find_if_not(start_digit, s.end(),
+
1438 [](char ch) { return std::isdigit(ch); });
+
1439
+
1440 if (start_digit == it) {
+
1441 throw std::invalid_argument("Invalid string format.");
+
1442 }
+
1443
+
1444 size_t n_base10 = std::distance(start_digit, it); // it - start_digit
+
1445 if (!uints::has_double_exact(n_base10)) {
+
1446 throw overflow_error("Too many decimal characters in the string.");
+
1447 }
+
1448
+
1449 // Theoretical number of base (bi_dmax + 1) digits required to represent any
+
1450 // base 10 number with n_base10 base 10 digits. See decimal_length().
+
1451 // conversion_ratio is 1 / log10(bi_base)
+
1452 constexpr double conversion_ratio = (bi_dwidth == 64) ? 0.052 : 0.104;
+
1453 const size_t n_digits = static_cast<size_t>(
+
1454 std::ceil(static_cast<double>(n_base10) * conversion_ratio));
+
1455
+
1456 x.reserve_(n_digits);
+
1457
+
1458 for (auto dec_it = start_digit; dec_it < it;) {
+
1459 /* We could replace all the code in the body of this loop with just
+
1460 * `imul1add1(10, *dec_it++ - '0');` and the end result will be the same.
+
1461 * However, it is more efficient to batch some base-10 digits together. */
+
1462 // Initialize batch value
+
1463 digit batch = 0;
+
1464
+
1465 // Calculate how many base-10 digits we can process in this batch
+
1466 const size_t remaining = std::distance(dec_it, it);
+
1467 const size_t digits_in_batch =
+
1468 std::min(remaining, static_cast<size_t>(max_batch_size));
+
1469
+
1470 // Convert batch substring to integer value
+
1471 for (size_t j = 0; j < digits_in_batch; ++j, ++dec_it) {
+
1472 // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)
+
1473 batch = (*dec_it - '0') + batch * 10;
+
1474 }
+
1475
+
1476 // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-constant-array-index)
+
1477 h_::imul1add1(x, powers_of_ten[digits_in_batch], batch);
+
1478 }
+
1479
+
1480 x.trim_trailing_zeros();
+
1481}
+
1482
+
1484
+
1486inline dvector h_::to_twos_complement(const dvector& vec) {
+
1487 const size_t vec_size = vec.size();
+
1488 dvector result;
+
1489 result.resize(vec_size);
+
1490
+
1491 bool carry = true;
+
1492 for (size_t i = 0; i < vec_size; ++i) {
+
1493 const digit sum = ~vec[i] + carry;
+
1494 carry = sum < static_cast<uint8_t>(carry);
+
1495 result[i] = sum;
+
1496 }
+
1497
+
1498 return result;
+
1499}
+
1500
+
1502inline void h_::to_twos_complement_in_place(dvector& vec) noexcept {
+
1503 const size_t vec_size = vec.size();
+
1504
+
1505 bool carry = true;
+
1506 for (size_t i = 0; i < vec_size; ++i) {
+
1507 const digit sum = ~vec[i] + carry;
+
1508 carry = sum < static_cast<uint8_t>(carry);
+
1509 vec[i] = sum;
+
1510 }
+
1511}
+
1512
+
1513} // namespace bi
+
1514
+
1515#endif // BI_SRC_H__HPP_
+
+ +
+Generated by doxygen 1.10.0 +
+ + diff --git a/menudata.js b/menudata.js index 25513b6..ea176fc 100644 --- a/menudata.js +++ b/menudata.js @@ -53,6 +53,4 @@ var menudata={children:[ {text:"p",url:"functions_func.html#index_p"}, {text:"s",url:"functions_func.html#index_s"}, {text:"t",url:"functions_func.html#index_t"}]}, -{text:"Related Symbols",url:"functions_rela.html"}]}]}, -{text:"Files",url:"files.html",children:[ -{text:"File List",url:"files.html"}]}]} +{text:"Related Symbols",url:"functions_rela.html"}]}]}]}