Projects : bitcoin : bitcoin_tx_fee_cleanup
1 | // Copyright (c) 2009-2010 Satoshi Nakamoto |
2 | // Copyright (c) 2011 The Bitcoin developers |
3 | // Distributed under the MIT/X11 software license, see the accompanying |
4 | // file license.txt or http://www.opensource.org/licenses/mit-license.php. |
5 | #ifndef BITCOIN_UINT256_H |
6 | #define BITCOIN_UINT256_H |
7 | |
8 | #include "serialize.h" |
9 | |
10 | #include <limits.h> |
11 | #include <string> |
12 | #include <vector> |
13 | |
14 | typedef long long int64; |
15 | typedef unsigned long long uint64; |
16 | |
17 | inline int Testuint256AdHoc(std::vector<std::string> vArg); |
18 | |
19 | |
20 | |
21 | // We have to keep a separate base class without constructors |
22 | // so the compiler will let us use it in a union |
23 | template<unsigned int BITS> |
24 | class base_uint |
25 | { |
26 | protected: |
27 | enum { WIDTH=BITS/32 }; |
28 | unsigned int pn[WIDTH]; |
29 | public: |
30 | |
31 | bool operator!() const |
32 | { |
33 | for (int i = 0; i < WIDTH; i++) |
34 | if (pn[i] != 0) |
35 | return false; |
36 | return true; |
37 | } |
38 | |
39 | const base_uint operator~() const |
40 | { |
41 | base_uint ret; |
42 | for (int i = 0; i < WIDTH; i++) |
43 | ret.pn[i] = ~pn[i]; |
44 | return ret; |
45 | } |
46 | |
47 | const base_uint operator-() const |
48 | { |
49 | base_uint ret; |
50 | for (int i = 0; i < WIDTH; i++) |
51 | ret.pn[i] = ~pn[i]; |
52 | ret++; |
53 | return ret; |
54 | } |
55 | |
56 | |
57 | base_uint& operator=(uint64 b) |
58 | { |
59 | pn[0] = (unsigned int)b; |
60 | pn[1] = (unsigned int)(b >> 32); |
61 | for (int i = 2; i < WIDTH; i++) |
62 | pn[i] = 0; |
63 | return *this; |
64 | } |
65 | |
66 | base_uint& operator^=(const base_uint& b) |
67 | { |
68 | for (int i = 0; i < WIDTH; i++) |
69 | pn[i] ^= b.pn[i]; |
70 | return *this; |
71 | } |
72 | |
73 | base_uint& operator&=(const base_uint& b) |
74 | { |
75 | for (int i = 0; i < WIDTH; i++) |
76 | pn[i] &= b.pn[i]; |
77 | return *this; |
78 | } |
79 | |
80 | base_uint& operator|=(const base_uint& b) |
81 | { |
82 | for (int i = 0; i < WIDTH; i++) |
83 | pn[i] |= b.pn[i]; |
84 | return *this; |
85 | } |
86 | |
87 | base_uint& operator^=(uint64 b) |
88 | { |
89 | pn[0] ^= (unsigned int)b; |
90 | pn[1] ^= (unsigned int)(b >> 32); |
91 | return *this; |
92 | } |
93 | |
94 | base_uint& operator|=(uint64 b) |
95 | { |
96 | pn[0] |= (unsigned int)b; |
97 | pn[1] |= (unsigned int)(b >> 32); |
98 | return *this; |
99 | } |
100 | |
101 | base_uint& operator<<=(unsigned int shift) |
102 | { |
103 | base_uint a(*this); |
104 | for (int i = 0; i < WIDTH; i++) |
105 | pn[i] = 0; |
106 | int k = shift / 32; |
107 | shift = shift % 32; |
108 | for (int i = 0; i < WIDTH; i++) |
109 | { |
110 | if (i+k+1 < WIDTH && shift != 0) |
111 | pn[i+k+1] |= (a.pn[i] >> (32-shift)); |
112 | if (i+k < WIDTH) |
113 | pn[i+k] |= (a.pn[i] << shift); |
114 | } |
115 | return *this; |
116 | } |
117 | |
118 | base_uint& operator>>=(unsigned int shift) |
119 | { |
120 | base_uint a(*this); |
121 | for (int i = 0; i < WIDTH; i++) |
122 | pn[i] = 0; |
123 | int k = shift / 32; |
124 | shift = shift % 32; |
125 | for (int i = 0; i < WIDTH; i++) |
126 | { |
127 | if (i-k-1 >= 0 && shift != 0) |
128 | pn[i-k-1] |= (a.pn[i] << (32-shift)); |
129 | if (i-k >= 0) |
130 | pn[i-k] |= (a.pn[i] >> shift); |
131 | } |
132 | return *this; |
133 | } |
134 | |
135 | base_uint& operator+=(const base_uint& b) |
136 | { |
137 | uint64 carry = 0; |
138 | for (int i = 0; i < WIDTH; i++) |
139 | { |
140 | uint64 n = carry + pn[i] + b.pn[i]; |
141 | pn[i] = n & 0xffffffff; |
142 | carry = n >> 32; |
143 | } |
144 | return *this; |
145 | } |
146 | |
147 | base_uint& operator-=(const base_uint& b) |
148 | { |
149 | *this += -b; |
150 | return *this; |
151 | } |
152 | |
153 | base_uint& operator+=(uint64 b64) |
154 | { |
155 | base_uint b; |
156 | b = b64; |
157 | *this += b; |
158 | return *this; |
159 | } |
160 | |
161 | base_uint& operator-=(uint64 b64) |
162 | { |
163 | base_uint b; |
164 | b = b64; |
165 | *this += -b; |
166 | return *this; |
167 | } |
168 | |
169 | |
170 | base_uint& operator++() |
171 | { |
172 | // prefix operator |
173 | int i = 0; |
174 | while (++pn[i] == 0 && i < WIDTH-1) |
175 | i++; |
176 | return *this; |
177 | } |
178 | |
179 | const base_uint operator++(int) |
180 | { |
181 | // postfix operator |
182 | const base_uint ret = *this; |
183 | ++(*this); |
184 | return ret; |
185 | } |
186 | |
187 | base_uint& operator--() |
188 | { |
189 | // prefix operator |
190 | int i = 0; |
191 | while (--pn[i] == -1 && i < WIDTH-1) |
192 | i++; |
193 | return *this; |
194 | } |
195 | |
196 | const base_uint operator--(int) |
197 | { |
198 | // postfix operator |
199 | const base_uint ret = *this; |
200 | --(*this); |
201 | return ret; |
202 | } |
203 | |
204 | |
205 | friend inline bool operator<(const base_uint& a, const base_uint& b) |
206 | { |
207 | for (int i = base_uint::WIDTH-1; i >= 0; i--) |
208 | { |
209 | if (a.pn[i] < b.pn[i]) |
210 | return true; |
211 | else if (a.pn[i] > b.pn[i]) |
212 | return false; |
213 | } |
214 | return false; |
215 | } |
216 | |
217 | friend inline bool operator<=(const base_uint& a, const base_uint& b) |
218 | { |
219 | for (int i = base_uint::WIDTH-1; i >= 0; i--) |
220 | { |
221 | if (a.pn[i] < b.pn[i]) |
222 | return true; |
223 | else if (a.pn[i] > b.pn[i]) |
224 | return false; |
225 | } |
226 | return true; |
227 | } |
228 | |
229 | friend inline bool operator>(const base_uint& a, const base_uint& b) |
230 | { |
231 | for (int i = base_uint::WIDTH-1; i >= 0; i--) |
232 | { |
233 | if (a.pn[i] > b.pn[i]) |
234 | return true; |
235 | else if (a.pn[i] < b.pn[i]) |
236 | return false; |
237 | } |
238 | return false; |
239 | } |
240 | |
241 | friend inline bool operator>=(const base_uint& a, const base_uint& b) |
242 | { |
243 | for (int i = base_uint::WIDTH-1; i >= 0; i--) |
244 | { |
245 | if (a.pn[i] > b.pn[i]) |
246 | return true; |
247 | else if (a.pn[i] < b.pn[i]) |
248 | return false; |
249 | } |
250 | return true; |
251 | } |
252 | |
253 | friend inline bool operator==(const base_uint& a, const base_uint& b) |
254 | { |
255 | for (int i = 0; i < base_uint::WIDTH; i++) |
256 | if (a.pn[i] != b.pn[i]) |
257 | return false; |
258 | return true; |
259 | } |
260 | |
261 | friend inline bool operator==(const base_uint& a, uint64 b) |
262 | { |
263 | if (a.pn[0] != (unsigned int)b) |
264 | return false; |
265 | if (a.pn[1] != (unsigned int)(b >> 32)) |
266 | return false; |
267 | for (int i = 2; i < base_uint::WIDTH; i++) |
268 | if (a.pn[i] != 0) |
269 | return false; |
270 | return true; |
271 | } |
272 | |
273 | friend inline bool operator!=(const base_uint& a, const base_uint& b) |
274 | { |
275 | return (!(a == b)); |
276 | } |
277 | |
278 | friend inline bool operator!=(const base_uint& a, uint64 b) |
279 | { |
280 | return (!(a == b)); |
281 | } |
282 | |
283 | |
284 | |
285 | std::string GetHex() const |
286 | { |
287 | char psz[sizeof(pn)*2 + 1]; |
288 | for (int i = 0; i < sizeof(pn); i++) |
289 | sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]); |
290 | return std::string(psz, psz + sizeof(pn)*2); |
291 | } |
292 | |
293 | void SetHex(const char* psz) |
294 | { |
295 | for (int i = 0; i < WIDTH; i++) |
296 | pn[i] = 0; |
297 | |
298 | // skip leading spaces |
299 | while (isspace(*psz)) |
300 | psz++; |
301 | |
302 | // skip 0x |
303 | if (psz[0] == '0' && tolower(psz[1]) == 'x') |
304 | psz += 2; |
305 | |
306 | // hex string to uint |
307 | static char phexdigit[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 }; |
308 | const char* pbegin = psz; |
309 | while (phexdigit[*psz] || *psz == '0') |
310 | psz++; |
311 | psz--; |
312 | unsigned char* p1 = (unsigned char*)pn; |
313 | unsigned char* pend = p1 + WIDTH * 4; |
314 | while (psz >= pbegin && p1 < pend) |
315 | { |
316 | *p1 = phexdigit[(unsigned char)*psz--]; |
317 | if (psz >= pbegin) |
318 | { |
319 | *p1 |= (phexdigit[(unsigned char)*psz--] << 4); |
320 | p1++; |
321 | } |
322 | } |
323 | } |
324 | |
325 | void SetHex(const std::string& str) |
326 | { |
327 | SetHex(str.c_str()); |
328 | } |
329 | |
330 | std::string ToString() const |
331 | { |
332 | return (GetHex()); |
333 | } |
334 | |
335 | unsigned char* begin() |
336 | { |
337 | return (unsigned char*)&pn[0]; |
338 | } |
339 | |
340 | unsigned char* end() |
341 | { |
342 | return (unsigned char*)&pn[WIDTH]; |
343 | } |
344 | |
345 | unsigned int size() |
346 | { |
347 | return sizeof(pn); |
348 | } |
349 | |
350 | |
351 | unsigned int GetSerializeSize(int nType=0, int nVersion=VERSION) const |
352 | { |
353 | return sizeof(pn); |
354 | } |
355 | |
356 | template<typename Stream> |
357 | void Serialize(Stream& s, int nType=0, int nVersion=VERSION) const |
358 | { |
359 | s.write((char*)pn, sizeof(pn)); |
360 | } |
361 | |
362 | template<typename Stream> |
363 | void Unserialize(Stream& s, int nType=0, int nVersion=VERSION) |
364 | { |
365 | s.read((char*)pn, sizeof(pn)); |
366 | } |
367 | |
368 | |
369 | friend class uint160; |
370 | friend class uint256; |
371 | friend inline int Testuint256AdHoc(std::vector<std::string> vArg); |
372 | }; |
373 | |
374 | typedef base_uint<160> base_uint160; |
375 | typedef base_uint<256> base_uint256; |
376 | |
377 | |
378 | |
379 | // |
380 | // uint160 and uint256 could be implemented as templates, but to keep |
381 | // compile errors and debugging cleaner, they're copy and pasted. |
382 | // |
383 | |
384 | |
385 | |
386 | ////////////////////////////////////////////////////////////////////////////// |
387 | // |
388 | // uint160 |
389 | // |
390 | |
391 | class uint160 : public base_uint160 |
392 | { |
393 | public: |
394 | typedef base_uint160 basetype; |
395 | |
396 | uint160() |
397 | { |
398 | for (int i = 0; i < WIDTH; i++) |
399 | pn[i] = 0; |
400 | } |
401 | |
402 | uint160(const basetype& b) |
403 | { |
404 | for (int i = 0; i < WIDTH; i++) |
405 | pn[i] = b.pn[i]; |
406 | } |
407 | |
408 | uint160& operator=(const basetype& b) |
409 | { |
410 | for (int i = 0; i < WIDTH; i++) |
411 | pn[i] = b.pn[i]; |
412 | return *this; |
413 | } |
414 | |
415 | uint160(uint64 b) |
416 | { |
417 | pn[0] = (unsigned int)b; |
418 | pn[1] = (unsigned int)(b >> 32); |
419 | for (int i = 2; i < WIDTH; i++) |
420 | pn[i] = 0; |
421 | } |
422 | |
423 | uint160& operator=(uint64 b) |
424 | { |
425 | pn[0] = (unsigned int)b; |
426 | pn[1] = (unsigned int)(b >> 32); |
427 | for (int i = 2; i < WIDTH; i++) |
428 | pn[i] = 0; |
429 | return *this; |
430 | } |
431 | |
432 | explicit uint160(const std::string& str) |
433 | { |
434 | SetHex(str); |
435 | } |
436 | |
437 | explicit uint160(const std::vector<unsigned char>& vch) |
438 | { |
439 | if (vch.size() == sizeof(pn)) |
440 | memcpy(pn, &vch[0], sizeof(pn)); |
441 | else |
442 | *this = 0; |
443 | } |
444 | }; |
445 | |
446 | inline bool operator==(const uint160& a, uint64 b) { return (base_uint160)a == b; } |
447 | inline bool operator!=(const uint160& a, uint64 b) { return (base_uint160)a != b; } |
448 | inline const uint160 operator<<(const base_uint160& a, unsigned int shift) { return uint160(a) <<= shift; } |
449 | inline const uint160 operator>>(const base_uint160& a, unsigned int shift) { return uint160(a) >>= shift; } |
450 | inline const uint160 operator<<(const uint160& a, unsigned int shift) { return uint160(a) <<= shift; } |
451 | inline const uint160 operator>>(const uint160& a, unsigned int shift) { return uint160(a) >>= shift; } |
452 | |
453 | inline const uint160 operator^(const base_uint160& a, const base_uint160& b) { return uint160(a) ^= b; } |
454 | inline const uint160 operator&(const base_uint160& a, const base_uint160& b) { return uint160(a) &= b; } |
455 | inline const uint160 operator|(const base_uint160& a, const base_uint160& b) { return uint160(a) |= b; } |
456 | inline const uint160 operator+(const base_uint160& a, const base_uint160& b) { return uint160(a) += b; } |
457 | inline const uint160 operator-(const base_uint160& a, const base_uint160& b) { return uint160(a) -= b; } |
458 | |
459 | inline bool operator<(const base_uint160& a, const uint160& b) { return (base_uint160)a < (base_uint160)b; } |
460 | inline bool operator<=(const base_uint160& a, const uint160& b) { return (base_uint160)a <= (base_uint160)b; } |
461 | inline bool operator>(const base_uint160& a, const uint160& b) { return (base_uint160)a > (base_uint160)b; } |
462 | inline bool operator>=(const base_uint160& a, const uint160& b) { return (base_uint160)a >= (base_uint160)b; } |
463 | inline bool operator==(const base_uint160& a, const uint160& b) { return (base_uint160)a == (base_uint160)b; } |
464 | inline bool operator!=(const base_uint160& a, const uint160& b) { return (base_uint160)a != (base_uint160)b; } |
465 | inline const uint160 operator^(const base_uint160& a, const uint160& b) { return (base_uint160)a ^ (base_uint160)b; } |
466 | inline const uint160 operator&(const base_uint160& a, const uint160& b) { return (base_uint160)a & (base_uint160)b; } |
467 | inline const uint160 operator|(const base_uint160& a, const uint160& b) { return (base_uint160)a | (base_uint160)b; } |
468 | inline const uint160 operator+(const base_uint160& a, const uint160& b) { return (base_uint160)a + (base_uint160)b; } |
469 | inline const uint160 operator-(const base_uint160& a, const uint160& b) { return (base_uint160)a - (base_uint160)b; } |
470 | |
471 | inline bool operator<(const uint160& a, const base_uint160& b) { return (base_uint160)a < (base_uint160)b; } |
472 | inline bool operator<=(const uint160& a, const base_uint160& b) { return (base_uint160)a <= (base_uint160)b; } |
473 | inline bool operator>(const uint160& a, const base_uint160& b) { return (base_uint160)a > (base_uint160)b; } |
474 | inline bool operator>=(const uint160& a, const base_uint160& b) { return (base_uint160)a >= (base_uint160)b; } |
475 | inline bool operator==(const uint160& a, const base_uint160& b) { return (base_uint160)a == (base_uint160)b; } |
476 | inline bool operator!=(const uint160& a, const base_uint160& b) { return (base_uint160)a != (base_uint160)b; } |
477 | inline const uint160 operator^(const uint160& a, const base_uint160& b) { return (base_uint160)a ^ (base_uint160)b; } |
478 | inline const uint160 operator&(const uint160& a, const base_uint160& b) { return (base_uint160)a & (base_uint160)b; } |
479 | inline const uint160 operator|(const uint160& a, const base_uint160& b) { return (base_uint160)a | (base_uint160)b; } |
480 | inline const uint160 operator+(const uint160& a, const base_uint160& b) { return (base_uint160)a + (base_uint160)b; } |
481 | inline const uint160 operator-(const uint160& a, const base_uint160& b) { return (base_uint160)a - (base_uint160)b; } |
482 | |
483 | inline bool operator<(const uint160& a, const uint160& b) { return (base_uint160)a < (base_uint160)b; } |
484 | inline bool operator<=(const uint160& a, const uint160& b) { return (base_uint160)a <= (base_uint160)b; } |
485 | inline bool operator>(const uint160& a, const uint160& b) { return (base_uint160)a > (base_uint160)b; } |
486 | inline bool operator>=(const uint160& a, const uint160& b) { return (base_uint160)a >= (base_uint160)b; } |
487 | inline bool operator==(const uint160& a, const uint160& b) { return (base_uint160)a == (base_uint160)b; } |
488 | inline bool operator!=(const uint160& a, const uint160& b) { return (base_uint160)a != (base_uint160)b; } |
489 | inline const uint160 operator^(const uint160& a, const uint160& b) { return (base_uint160)a ^ (base_uint160)b; } |
490 | inline const uint160 operator&(const uint160& a, const uint160& b) { return (base_uint160)a & (base_uint160)b; } |
491 | inline const uint160 operator|(const uint160& a, const uint160& b) { return (base_uint160)a | (base_uint160)b; } |
492 | inline const uint160 operator+(const uint160& a, const uint160& b) { return (base_uint160)a + (base_uint160)b; } |
493 | inline const uint160 operator-(const uint160& a, const uint160& b) { return (base_uint160)a - (base_uint160)b; } |
494 | |
495 | |
496 | |
497 | |
498 | |
499 | |
500 | ////////////////////////////////////////////////////////////////////////////// |
501 | // |
502 | // uint256 |
503 | // |
504 | |
505 | class uint256 : public base_uint256 |
506 | { |
507 | public: |
508 | typedef base_uint256 basetype; |
509 | |
510 | uint256() |
511 | { |
512 | for (int i = 0; i < WIDTH; i++) |
513 | pn[i] = 0; |
514 | } |
515 | |
516 | uint256(const basetype& b) |
517 | { |
518 | for (int i = 0; i < WIDTH; i++) |
519 | pn[i] = b.pn[i]; |
520 | } |
521 | |
522 | uint256& operator=(const basetype& b) |
523 | { |
524 | for (int i = 0; i < WIDTH; i++) |
525 | pn[i] = b.pn[i]; |
526 | return *this; |
527 | } |
528 | |
529 | uint256(uint64 b) |
530 | { |
531 | pn[0] = (unsigned int)b; |
532 | pn[1] = (unsigned int)(b >> 32); |
533 | for (int i = 2; i < WIDTH; i++) |
534 | pn[i] = 0; |
535 | } |
536 | |
537 | uint256& operator=(uint64 b) |
538 | { |
539 | pn[0] = (unsigned int)b; |
540 | pn[1] = (unsigned int)(b >> 32); |
541 | for (int i = 2; i < WIDTH; i++) |
542 | pn[i] = 0; |
543 | return *this; |
544 | } |
545 | |
546 | explicit uint256(const std::string& str) |
547 | { |
548 | SetHex(str); |
549 | } |
550 | |
551 | explicit uint256(const std::vector<unsigned char>& vch) |
552 | { |
553 | if (vch.size() == sizeof(pn)) |
554 | memcpy(pn, &vch[0], sizeof(pn)); |
555 | else |
556 | *this = 0; |
557 | } |
558 | }; |
559 | |
560 | inline bool operator==(const uint256& a, uint64 b) { return (base_uint256)a == b; } |
561 | inline bool operator!=(const uint256& a, uint64 b) { return (base_uint256)a != b; } |
562 | inline const uint256 operator<<(const base_uint256& a, unsigned int shift) { return uint256(a) <<= shift; } |
563 | inline const uint256 operator>>(const base_uint256& a, unsigned int shift) { return uint256(a) >>= shift; } |
564 | inline const uint256 operator<<(const uint256& a, unsigned int shift) { return uint256(a) <<= shift; } |
565 | inline const uint256 operator>>(const uint256& a, unsigned int shift) { return uint256(a) >>= shift; } |
566 | |
567 | inline const uint256 operator^(const base_uint256& a, const base_uint256& b) { return uint256(a) ^= b; } |
568 | inline const uint256 operator&(const base_uint256& a, const base_uint256& b) { return uint256(a) &= b; } |
569 | inline const uint256 operator|(const base_uint256& a, const base_uint256& b) { return uint256(a) |= b; } |
570 | inline const uint256 operator+(const base_uint256& a, const base_uint256& b) { return uint256(a) += b; } |
571 | inline const uint256 operator-(const base_uint256& a, const base_uint256& b) { return uint256(a) -= b; } |
572 | |
573 | inline bool operator<(const base_uint256& a, const uint256& b) { return (base_uint256)a < (base_uint256)b; } |
574 | inline bool operator<=(const base_uint256& a, const uint256& b) { return (base_uint256)a <= (base_uint256)b; } |
575 | inline bool operator>(const base_uint256& a, const uint256& b) { return (base_uint256)a > (base_uint256)b; } |
576 | inline bool operator>=(const base_uint256& a, const uint256& b) { return (base_uint256)a >= (base_uint256)b; } |
577 | inline bool operator==(const base_uint256& a, const uint256& b) { return (base_uint256)a == (base_uint256)b; } |
578 | inline bool operator!=(const base_uint256& a, const uint256& b) { return (base_uint256)a != (base_uint256)b; } |
579 | inline const uint256 operator^(const base_uint256& a, const uint256& b) { return (base_uint256)a ^ (base_uint256)b; } |
580 | inline const uint256 operator&(const base_uint256& a, const uint256& b) { return (base_uint256)a & (base_uint256)b; } |
581 | inline const uint256 operator|(const base_uint256& a, const uint256& b) { return (base_uint256)a | (base_uint256)b; } |
582 | inline const uint256 operator+(const base_uint256& a, const uint256& b) { return (base_uint256)a + (base_uint256)b; } |
583 | inline const uint256 operator-(const base_uint256& a, const uint256& b) { return (base_uint256)a - (base_uint256)b; } |
584 | |
585 | inline bool operator<(const uint256& a, const base_uint256& b) { return (base_uint256)a < (base_uint256)b; } |
586 | inline bool operator<=(const uint256& a, const base_uint256& b) { return (base_uint256)a <= (base_uint256)b; } |
587 | inline bool operator>(const uint256& a, const base_uint256& b) { return (base_uint256)a > (base_uint256)b; } |
588 | inline bool operator>=(const uint256& a, const base_uint256& b) { return (base_uint256)a >= (base_uint256)b; } |
589 | inline bool operator==(const uint256& a, const base_uint256& b) { return (base_uint256)a == (base_uint256)b; } |
590 | inline bool operator!=(const uint256& a, const base_uint256& b) { return (base_uint256)a != (base_uint256)b; } |
591 | inline const uint256 operator^(const uint256& a, const base_uint256& b) { return (base_uint256)a ^ (base_uint256)b; } |
592 | inline const uint256 operator&(const uint256& a, const base_uint256& b) { return (base_uint256)a & (base_uint256)b; } |
593 | inline const uint256 operator|(const uint256& a, const base_uint256& b) { return (base_uint256)a | (base_uint256)b; } |
594 | inline const uint256 operator+(const uint256& a, const base_uint256& b) { return (base_uint256)a + (base_uint256)b; } |
595 | inline const uint256 operator-(const uint256& a, const base_uint256& b) { return (base_uint256)a - (base_uint256)b; } |
596 | |
597 | inline bool operator<(const uint256& a, const uint256& b) { return (base_uint256)a < (base_uint256)b; } |
598 | inline bool operator<=(const uint256& a, const uint256& b) { return (base_uint256)a <= (base_uint256)b; } |
599 | inline bool operator>(const uint256& a, const uint256& b) { return (base_uint256)a > (base_uint256)b; } |
600 | inline bool operator>=(const uint256& a, const uint256& b) { return (base_uint256)a >= (base_uint256)b; } |
601 | inline bool operator==(const uint256& a, const uint256& b) { return (base_uint256)a == (base_uint256)b; } |
602 | inline bool operator!=(const uint256& a, const uint256& b) { return (base_uint256)a != (base_uint256)b; } |
603 | inline const uint256 operator^(const uint256& a, const uint256& b) { return (base_uint256)a ^ (base_uint256)b; } |
604 | inline const uint256 operator&(const uint256& a, const uint256& b) { return (base_uint256)a & (base_uint256)b; } |
605 | inline const uint256 operator|(const uint256& a, const uint256& b) { return (base_uint256)a | (base_uint256)b; } |
606 | inline const uint256 operator+(const uint256& a, const uint256& b) { return (base_uint256)a + (base_uint256)b; } |
607 | inline const uint256 operator-(const uint256& a, const uint256& b) { return (base_uint256)a - (base_uint256)b; } |
608 | |
609 | |
610 | |
611 | |
612 | |
613 | |
614 | |
615 | |
616 | |
617 | |
618 | |
619 | |
620 | inline int Testuint256AdHoc(std::vector<std::string> vArg) |
621 | { |
622 | uint256 g(0); |
623 | |
624 | |
625 | printf("%s\n", g.ToString().c_str()); |
626 | g--; printf("g--\n"); |
627 | printf("%s\n", g.ToString().c_str()); |
628 | g--; printf("g--\n"); |
629 | printf("%s\n", g.ToString().c_str()); |
630 | g++; printf("g++\n"); |
631 | printf("%s\n", g.ToString().c_str()); |
632 | g++; printf("g++\n"); |
633 | printf("%s\n", g.ToString().c_str()); |
634 | g++; printf("g++\n"); |
635 | printf("%s\n", g.ToString().c_str()); |
636 | g++; printf("g++\n"); |
637 | printf("%s\n", g.ToString().c_str()); |
638 | |
639 | |
640 | |
641 | uint256 a(7); |
642 | printf("a=7\n"); |
643 | printf("%s\n", a.ToString().c_str()); |
644 | |
645 | uint256 b; |
646 | printf("b undefined\n"); |
647 | printf("%s\n", b.ToString().c_str()); |
648 | int c = 3; |
649 | |
650 | a = c; |
651 | a.pn[3] = 15; |
652 | printf("%s\n", a.ToString().c_str()); |
653 | uint256 k(c); |
654 | |
655 | a = 5; |
656 | a.pn[3] = 15; |
657 | printf("%s\n", a.ToString().c_str()); |
658 | b = 1; |
659 | b <<= 52; |
660 | |
661 | a |= b; |
662 | |
663 | a ^= 0x500; |
664 | |
665 | printf("a %s\n", a.ToString().c_str()); |
666 | |
667 | a = a | b | (uint256)0x1000; |
668 | |
669 | |
670 | printf("a %s\n", a.ToString().c_str()); |
671 | printf("b %s\n", b.ToString().c_str()); |
672 | |
673 | a = 0xfffffffe; |
674 | a.pn[4] = 9; |
675 | |
676 | printf("%s\n", a.ToString().c_str()); |
677 | a++; |
678 | printf("%s\n", a.ToString().c_str()); |
679 | a++; |
680 | printf("%s\n", a.ToString().c_str()); |
681 | a++; |
682 | printf("%s\n", a.ToString().c_str()); |
683 | a++; |
684 | printf("%s\n", a.ToString().c_str()); |
685 | |
686 | a--; |
687 | printf("%s\n", a.ToString().c_str()); |
688 | a--; |
689 | printf("%s\n", a.ToString().c_str()); |
690 | a--; |
691 | printf("%s\n", a.ToString().c_str()); |
692 | uint256 d = a--; |
693 | printf("%s\n", d.ToString().c_str()); |
694 | printf("%s\n", a.ToString().c_str()); |
695 | a--; |
696 | printf("%s\n", a.ToString().c_str()); |
697 | a--; |
698 | printf("%s\n", a.ToString().c_str()); |
699 | |
700 | d = a; |
701 | |
702 | printf("%s\n", d.ToString().c_str()); |
703 | for (int i = uint256::WIDTH-1; i >= 0; i--) printf("%08x", d.pn[i]); printf("\n"); |
704 | |
705 | uint256 neg = d; |
706 | neg = ~neg; |
707 | printf("%s\n", neg.ToString().c_str()); |
708 | |
709 | |
710 | uint256 e = uint256("0xABCDEF123abcdef12345678909832180000011111111"); |
711 | printf("\n"); |
712 | printf("%s\n", e.ToString().c_str()); |
713 | |
714 | |
715 | printf("\n"); |
716 | uint256 x1 = uint256("0xABCDEF123abcdef12345678909832180000011111111"); |
717 | uint256 x2; |
718 | printf("%s\n", x1.ToString().c_str()); |
719 | for (int i = 0; i < 270; i += 4) |
720 | { |
721 | x2 = x1 << i; |
722 | printf("%s\n", x2.ToString().c_str()); |
723 | } |
724 | |
725 | printf("\n"); |
726 | printf("%s\n", x1.ToString().c_str()); |
727 | for (int i = 0; i < 270; i += 4) |
728 | { |
729 | x2 = x1; |
730 | x2 >>= i; |
731 | printf("%s\n", x2.ToString().c_str()); |
732 | } |
733 | |
734 | |
735 | for (int i = 0; i < 100; i++) |
736 | { |
737 | uint256 k = (~uint256(0) >> i); |
738 | printf("%s\n", k.ToString().c_str()); |
739 | } |
740 | |
741 | for (int i = 0; i < 100; i++) |
742 | { |
743 | uint256 k = (~uint256(0) << i); |
744 | printf("%s\n", k.ToString().c_str()); |
745 | } |
746 | |
747 | return (0); |
748 | } |
749 | |
750 | #endif |