src/uint256.h

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